itd-api 0.7.1 → 0.8.0

package/dist/shared/{render-vtLixIiU.js → render-CiL1VS0b.js}

@@ -1,7 +1,752 @@
-import { F as pickArray, I as pickBoolean, L as pickNumber, P as isRecord, R as pickObject, et as createDeviceId, nt as isFile, p as InteractionType, q as STATUS_SERVICE, r as normalizeNotification, tt as isBlob, v as ReportReason, x as SpanType, y as ReportTargetType, z as pickString } from "./url-CYXgxqGx.js";
-import { a as ItdConfigError, l as ItdFileError, s as ItdError, u as ItdFileErrorReason } from "./errors-Bhrd2fJd.js";
-import { o as encodePathSegment } from "./cookies-tX2sNwxb.js";
-import { a as fileTooLarge, c as FileTransferMode, i as isReadableByteStream, n as boundedFileStream, o as optionalBytes, r as isBoundedFileStream, s as DEFAULT_URL_FILE_MAX_BYTES, t as resolveFileStreamOptions } from "./options-DtATYdLr.js";
+import { B as isRecord, C as ReportReason, E as SpanType, G as pickString, H as pickBoolean, J as identityResult, K as RetrySafety, M as defineBuiltInOperation, U as pickNumber, V as pickArray, W as pickObject, Y as mergeService, c as normalizeNotification, et as DEFAULT_STATUS_BASE_URL, o as passthroughOperation, q as defineOperation, s as voidOperation, st as createDeadline, tt as STATUS_SERVICE, w as ReportTargetType, y as InteractionType } from "./url-B3ocFlHj.js";
+import { _ as ItdStateError, a as ItdConfigError, l as ItdFileError, s as ItdError, t as ItdAbortError, u as ItdFileErrorReason } from "./errors-GI10kZxk.js";
+import { a as redactUrl, b as isFile, d as encodePathSegment, r as redactErrorCause, v as createDeviceId, y as isBlob } from "./redact-FNK29Fv-.js";
+import { a as fileTooLarge, c as FileTransferMode, i as isReadableByteStream, n as boundedFileStream, o as optionalBytes, r as isBoundedFileStream, s as DEFAULT_URL_FILE_MAX_BYTES, t as resolveFileStreamOptions } from "./options-BNP633A5.js";
+//#region src/core/feature-catalog.ts
+/**
+* Изменяемый слой над каталогом конкретного API.
+*
+* Базовый каталог остаётся замороженным и общим для всех клиентов, а регистрации feature
+* принадлежат одному facade. Поэтому установка модуля в одном клиенте не меняет остальные.
+*
+* @internal
+*/
+var ExtensibleOperationCatalog = class {
+	#base;
+	#operations = /* @__PURE__ */ new Map();
+	#operationOwners = /* @__PURE__ */ new Map();
+	#bucketOwners = /* @__PURE__ */ new Map();
+	#bucketLimits;
+	#bucketOverrides;
+	constructor(base) {
+		this.#base = base;
+		this.#bucketLimits = { ...base.bucketLimits };
+		this.#bucketOverrides = { ...base.bucketOverrides };
+	}
+	get bucketLimits() {
+		return this.#bucketLimits;
+	}
+	get bucketOverrides() {
+		return this.#bucketOverrides;
+	}
+	get defaultBucket() {
+		return this.#base.defaultBucket;
+	}
+	definitionOf(id) {
+		return this.#operations.get(id) ?? this.#base.definitionOf(id);
+	}
+	retrySafetyOf(id) {
+		return this.#operations.get(id)?.retrySafety ?? this.#base.retrySafetyOf(id);
+	}
+	methodOf(id) {
+		return this.#operations.get(id)?.method ?? this.#base.methodOf(id);
+	}
+	bucketOf(id) {
+		return this.#operations.get(id)?.bucket ?? this.#base.bucketOf(id);
+	}
+	isKnownBucket(name) {
+		return this.#bucketOwners.has(name) || this.#base.isKnownBucket(name);
+	}
+	/** Регистрирует принадлежащий feature бакет и возвращает откат регистрации. */
+	registerBucket(owner, name, definition) {
+		if (this.#base.isKnownBucket(name) || this.#bucketOwners.has(name)) throw new ItdConfigError(`feature «${owner}»: бакет «${name}» уже зарегистрирован`);
+		this.#bucketOwners.set(name, owner);
+		if (definition.limit !== void 0) this.#bucketLimits[name] = definition.limit;
+		if (definition.concurrency !== void 0 || definition.rps !== void 0) this.#bucketOverrides[name] = Object.freeze({
+			...definition.concurrency === void 0 ? {} : { concurrency: definition.concurrency },
+			...definition.rps === void 0 ? {} : { rps: definition.rps }
+		});
+		return () => {
+			if (this.#bucketOwners.get(name) !== owner) return;
+			this.#bucketOwners.delete(name);
+			delete this.#bucketLimits[name];
+			delete this.#bucketOverrides[name];
+		};
+	}
+	/** Регистрирует операцию и возвращает откат регистрации. */
+	registerOperation(owner, id, definition) {
+		const ownerPrefix = `${owner}.`;
+		if (!id.startsWith(ownerPrefix) || id.length === ownerPrefix.length) throw new ItdConfigError(`feature «${owner}»: операция «${id}» должна находиться в пространстве имён «${owner}»`);
+		const occupiedBy = this.#operationOwners.get(id);
+		if (occupiedBy !== void 0) throw new ItdConfigError(`feature «${owner}»: операция «${id}» уже зарегистрирована feature «${occupiedBy}»`);
+		if (this.#base.methodOf(id) !== void 0) throw new ItdConfigError(`feature «${owner}»: операция «${id}» уже существует в базовом каталоге`);
+		this.#operationOwners.set(id, owner);
+		this.#operations.set(id, Object.freeze({ ...definition }));
+		return () => {
+			if (this.#operationOwners.get(id) !== owner) return;
+			this.#operationOwners.delete(id);
+			this.#operations.delete(id);
+		};
+	}
+};
+//#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 fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new ItdConfigError(`«${redactUrl(target)}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new 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;
+		const safeUrl = redactUrl(requested.href);
+		throw new ItdFileError(`не удалось получить файл по адресу ${safeUrl}`, {
+			reason: ItdFileErrorReason.Network,
+			url: safeUrl,
+			retryable: true,
+			cause: redactErrorCause(error)
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		const safeUrl = redactUrl(finalUrl.href);
+		throw new ItdFileError(`источник ${safeUrl} ответил статусом ${response.status}`, {
+			reason: ItdFileErrorReason.Http,
+			url: safeUrl,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = resolveFileStreamOptions(options, 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 fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = 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 = resolveFileStreamOptions(options, 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 = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) {
+		const safeUrl = redactUrl(url.href);
+		throw new ItdFileError(`источник ${safeUrl} не предоставил потоковое тело`, {
+			reason: ItdFileErrorReason.StreamUnavailable,
+			url: safeUrl
+		});
+	}
+	const stream = 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/attachments/resolver.ts
+/** Возвращает функцию освобождения, которая исполняет действие не более одного раза. */
+function closeOnce(action) {
+	let closing;
+	return () => closing ??= Promise.resolve().then(action);
+}
+/** Добавляет поле только для непустого значения, не выдумывая имя или MIME. */
+function optionalText(name, value) {
+	const normalized = value?.trim();
+	return normalized ? { [name]: normalized } : {};
+}
+/** Единая реализация распознавания и открытия `FileInput`. @internal */
+var DefaultFileResolver = class {
+	#fetch;
+	constructor(fetchImplementation) {
+		this.#fetch = fetchImplementation;
+	}
+	mode(input) {
+		if (typeof input !== "object" || input === null) return FileTransferMode.Buffer;
+		if ("open" in input) return FileTransferMode.Stream;
+		if ("url" in input) return resolveFileStreamOptions(input).mode;
+		return FileTransferMode.Buffer;
+	}
+	async resolve(input, options = {}, context = {}) {
+		const attempt = context.attempt ?? 1;
+		if (!Number.isInteger(attempt) || attempt < 1) throw new ItdConfigError(`attempt должен быть целым числом от 1, получено: ${attempt}`);
+		const maxBytes = optionalBytes(options.maxBytes, "maxBytes");
+		if (context.signal?.aborted) throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+		const fileContext = {
+			fetch: this.#fetch,
+			attempt,
+			...context.signal ? { signal: context.signal } : {}
+		};
+		try {
+			const source = this.mode(input) === FileTransferMode.Stream ? await this.#openStream(input, options, fileContext, maxBytes) : await this.#loadBuffer(input, options, fileContext, maxBytes);
+			if (context.signal?.aborted) {
+				if (source.mode === FileTransferMode.Stream) await source.close();
+				throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			return source;
+		} catch (error) {
+			if (error instanceof ItdError || context.signal?.aborted) throw error;
+			throw new ItdFileError("не удалось получить содержимое вложения", {
+				reason: ItdFileErrorReason.Read,
+				retryable: true,
+				cause: redactErrorCause(error)
+			});
+		}
+	}
+	async #loadBuffer(input, options, context, maxBytes) {
+		const content = await this.#resolveBuffer(input, context);
+		if (typeof content !== "object" || content === null || !("file" in content)) throw new ItdConfigError("буферный источник должен вернуть объект с полем file");
+		if (!isBlob(content.file) && !(content.file instanceof ArrayBuffer) && !ArrayBuffer.isView(content.file)) throw new ItdConfigError("поле file должно содержать Blob, ArrayBuffer или Uint8Array");
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(isBlob(content.file) ? content.file.type : void 0);
+		const blob = isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw fileTooLarge(void 0, maxBytes, blob.size);
+		return {
+			mode: FileTransferMode.Buffer,
+			blob,
+			size: blob.size,
+			...optionalText("filename", options.filename ?? content.filename),
+			contentType
+		};
+	}
+	async #openStream(input, options, context, maxBytes) {
+		const opened = await this.#resolveStream(input, context);
+		if (!opened || !isReadableByteStream(opened.stream)) {
+			await opened?.close?.();
+			throw new ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
+		}
+		let handedOff = false;
+		const closeOpened = closeOnce(async () => {
+			await opened.close?.();
+		});
+		try {
+			optionalBytes(opened.size, "size");
+			if (maxBytes !== void 0 && opened.size !== void 0 && opened.size > maxBytes) throw fileTooLarge(void 0, maxBytes, opened.size);
+			if (options.requireKnownSize === true && opened.size === void 0) throw new ItdConfigError("размер потокового вложения должен быть известен до чтения");
+			const limits = resolveFileStreamOptions({
+				mode: FileTransferMode.Stream,
+				...maxBytes !== void 0 ? { maxBytes } : {},
+				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
+			});
+			const stream = isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : boundedFileStream(opened.stream, {
+				...limits.maxBytes !== void 0 ? { maxBytes: limits.maxBytes } : {},
+				streamBufferBytes: limits.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {}
+			});
+			let detachAbort;
+			const close = closeOnce(async () => {
+				detachAbort?.();
+				detachAbort = void 0;
+				await stream.cancel().catch(() => {});
+				await closeOpened();
+			});
+			if (context.signal) {
+				const onAbort = () => {
+					close().catch(() => {});
+				};
+				if (context.signal.aborted) {
+					await close();
+					throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+				} else {
+					context.signal.addEventListener("abort", onAbort, { once: true });
+					detachAbort = () => context.signal?.removeEventListener("abort", onAbort);
+				}
+			}
+			handedOff = true;
+			return {
+				mode: FileTransferMode.Stream,
+				stream,
+				size: opened.size,
+				...optionalText("filename", options.filename ?? opened.filename),
+				contentType: normalizeMimeType(options.contentType ?? opened.contentType),
+				close
+			};
+		} finally {
+			if (!handedOff) await closeOpened();
+		}
+	}
+	#resolveBuffer(input, context) {
+		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || isBlob(input)) return {
+			file: input,
+			...isFile(input) ? { filename: input.name } : {}
+		};
+		if (typeof input !== "object" || input === null) throw new ItdConfigError(`вложение задано значением типа ${typeof input}; ожидается бинарное значение или объект { file }, { url }, { load }, { open }. Для файла на диске используйте fromPath('./photo.jpg') из itd-api/node`);
+		if ("load" in input) return input.load(context);
+		if ("url" in input) {
+			const { url, ...urlOptions } = input;
+			return downloadFile(url, urlOptions, context);
+		}
+		if ("file" in input) return input;
+		if ("open" in input) throw new ItdConfigError("потоковый источник нельзя использовать как буферный");
+		throw new ItdConfigError("вложение не распознано: ожидается { file }, { url }, { load } или { open }");
+	}
+	#resolveStream(input, context) {
+		if (typeof input === "object" && input !== null && "open" in input) return input.open(context);
+		if (typeof input === "object" && input !== null && "url" in input) {
+			const { url, ...urlOptions } = input;
+			return openUrlFile(url, urlOptions, context);
+		}
+		throw new ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
+	}
+};
+/** Создаёт механизм подготовки файлов, привязанный к настроенному `fetch` клиента. @internal */
+function createFileResolver(fetchImplementation) {
+	return new DefaultFileResolver(fetchImplementation);
+}
+//#endregion
+//#region src/core/features.ts
+function requireName(value, kind) {
+	if (typeof value !== "string" || value.trim() === "") throw new ItdConfigError(`${kind} должен иметь непустое имя`);
+	return value.trim();
+}
+function requireFeatureName(value) {
+	const name = requireName(value, "Feature");
+	if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new ItdConfigError(`имя feature «${name}» должно соответствовать [a-z][a-z0-9-]*`);
+	return name;
+}
+function validateBucket(owner, localName, bucket) {
+	if (typeof bucket !== "object" || bucket === null || Array.isArray(bucket)) throw new ItdConfigError(`feature «${owner}»: бакет «${localName}» должен быть объектом`);
+	if (bucket.limit !== void 0 && (!Number.isFinite(bucket.limit) || bucket.limit <= 0)) throw new ItdConfigError(`feature «${owner}»: limit бакета «${localName}» должен быть положительным числом`);
+	if (bucket.concurrency !== void 0 && (!Number.isInteger(bucket.concurrency) || bucket.concurrency < 1)) throw new ItdConfigError(`feature «${owner}»: concurrency бакета «${localName}» должен быть целым числом от 1`);
+	if (bucket.rps !== void 0 && (!Number.isFinite(bucket.rps) || bucket.rps <= 0)) throw new ItdConfigError(`feature «${owner}»: rps бакета «${localName}» должен быть положительным числом`);
+}
+/** Реестр подключаемых модулей клиента. @internal */
+var FeatureRegistry = class {
+	#deps;
+	#features = /* @__PURE__ */ new Map();
+	#serviceOwners = /* @__PURE__ */ new Map();
+	#disposed = false;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	install(feature) {
+		this.#deps.assertActive("установить feature");
+		if (this.#disposed) throw new ItdStateError("Реестр feature уже освобождён");
+		if (typeof feature !== "object" || feature === null) throw new ItdConfigError("feature должен быть объектом");
+		const name = requireFeatureName(feature.name);
+		if (this.#features.has(name)) throw new ItdConfigError(`feature «${name}» уже установлен`);
+		if (typeof feature.setup !== "function") throw new ItdConfigError(`feature «${name}» должен предоставлять setup()`);
+		if (typeof feature.operations !== "object" || feature.operations === null || Array.isArray(feature.operations)) throw new ItdConfigError(`feature «${name}» должен объявлять operations`);
+		if (feature.services !== void 0 && !Array.isArray(feature.services)) throw new ItdConfigError(`feature «${name}»: services должен быть массивом`);
+		if (feature.buckets !== void 0 && (typeof feature.buckets !== "object" || feature.buckets === null || Array.isArray(feature.buckets))) throw new ItdConfigError(`feature «${name}»: buckets должен быть объектом`);
+		const rollback = [];
+		const services = /* @__PURE__ */ new Set();
+		const bucketNames = /* @__PURE__ */ new Map();
+		const operations = /* @__PURE__ */ new Map();
+		const controller = new AbortController();
+		let committed = false;
+		const reportRollbackError = (message, error) => {
+			try {
+				this.#deps.logger?.error(message, error);
+			} catch {}
+		};
+		try {
+			for (const service of feature.services ?? []) {
+				const serviceName = requireName(service?.name, `Сервис feature «${name}»`);
+				const owner = this.#serviceOwners.get(serviceName);
+				if (owner !== void 0) throw new ItdConfigError(`feature «${name}»: сервис «${serviceName}» уже принадлежит feature «${owner}»`);
+				if (services.has(serviceName)) throw new ItdConfigError(`feature «${name}»: сервис «${serviceName}» объявлен повторно`);
+				if (!this.#deps.services.has(serviceName)) {
+					this.#deps.services.define(service);
+					rollback.push(() => void this.#deps.services.delete(serviceName));
+				} else {
+					const override = this.#deps.serviceOverrides.find((candidate) => candidate.name.trim() === serviceName);
+					if (override) {
+						const previous = this.#deps.services.replace(mergeService(service, override));
+						rollback.push(() => void this.#deps.services.replace(previous));
+					}
+				}
+				this.#serviceOwners.set(serviceName, name);
+				rollback.push(() => {
+					if (this.#serviceOwners.get(serviceName) === name) this.#serviceOwners.delete(serviceName);
+				});
+				services.add(serviceName);
+			}
+			for (const [rawLocalName, bucket] of Object.entries(feature.buckets ?? {})) {
+				const localName = requireName(rawLocalName, `Бакет feature «${name}»`);
+				validateBucket(name, localName, bucket);
+				const globalName = `feature:${name}/${localName}`;
+				const unregisterCatalog = this.#deps.catalog.registerBucket(name, globalName, bucket);
+				rollback.push(unregisterCatalog);
+				const unregisterQueue = this.#deps.registerBucket(globalName, bucket);
+				if (unregisterQueue) rollback.push(unregisterQueue);
+				bucketNames.set(localName, globalName);
+			}
+			for (const [rawLocalName, definition] of Object.entries(feature.operations)) {
+				const localName = requireName(rawLocalName, `Операция feature «${name}»`);
+				if (typeof definition !== "object" || definition === null) throw new ItdConfigError(`feature «${name}»: операция «${localName}» должна быть объектом`);
+				if (![
+					"GET",
+					"POST",
+					"PUT",
+					"PATCH",
+					"DELETE"
+				].includes(definition.method)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестный HTTP-метод`);
+				if (!Object.values(RetrySafety).includes(definition.retrySafety)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестную retrySafety`);
+				if (definition.service !== void 0 && typeof definition.service !== "string") throw new ItdConfigError(`feature «${name}»: service операции «${localName}» должен быть строкой`);
+				if (definition.bucket !== void 0 && typeof definition.bucket !== "string") throw new ItdConfigError(`feature «${name}»: bucket операции «${localName}» должен быть строкой`);
+				if (definition.read !== void 0 && typeof definition.read !== "function") throw new ItdConfigError(`feature «${name}»: read операции «${localName}» должна быть функцией`);
+				if (definition.annotations !== void 0 && (typeof definition.annotations !== "object" || definition.annotations === null || Array.isArray(definition.annotations))) throw new ItdConfigError(`feature «${name}»: annotations операции «${localName}» должны быть объектом`);
+				if (definition.service !== void 0 && !services.has(definition.service)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный сервис «${definition.service}»`);
+				const bucket = definition.bucket === void 0 ? this.#deps.catalog.defaultBucket : bucketNames.get(definition.bucket);
+				if (bucket === void 0) throw new ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный бакет «${definition.bucket}»`);
+				const operationId = `${name}.${localName}`;
+				const contract = defineOperation(operationId, {
+					method: definition.method,
+					retrySafety: definition.retrySafety,
+					bucket,
+					...definition.annotations === void 0 ? {} : { annotations: definition.annotations }
+				}, definition.read ?? identityResult);
+				const unregister = this.#deps.catalog.registerOperation(name, operationId, {
+					method: contract.method,
+					retrySafety: contract.retrySafety,
+					bucket,
+					...contract.annotations === void 0 ? {} : { annotations: contract.annotations }
+				});
+				rollback.push(unregister);
+				operations.set(localName, {
+					contract,
+					service: definition.service
+				});
+			}
+			const context = Object.freeze({
+				featureName: name,
+				baseUrl: this.#deps.baseUrl,
+				signal: controller.signal,
+				clock: this.#deps.clock,
+				logger: this.#deps.logger,
+				files: Object.freeze({ resolve: (input, options, context) => {
+					try {
+						this.#deps.assertActive(`открыть файловый источник feature «${name}»`);
+						if (!committed || controller.signal.aborted) throw new ItdStateError(`feature «${name}» не активен`);
+						return this.#deps.files.resolve(input, options, context);
+					} catch (error) {
+						return Promise.reject(error);
+					}
+				} }),
+				request: (operation, options) => {
+					try {
+						this.#deps.assertActive(`выполнить операцию feature «${name}»`);
+						if (!committed || controller.signal.aborted) throw new ItdStateError(`feature «${name}» не активен`);
+						const resolved = operations.get(operation);
+						if (!resolved) throw new ItdConfigError(`feature «${name}» не объявляет операцию «${operation}»`);
+						const scoped = { ...options };
+						delete scoped.operationId;
+						delete scoped.method;
+						delete scoped.service;
+						delete scoped.baseUrl;
+						delete scoped.retrySafety;
+						delete scoped.rateLimitBucket;
+						return this.#deps.http.execute(resolved.contract, {
+							...scoped,
+							...resolved.service === void 0 ? {} : { service: resolved.service }
+						});
+					} catch (error) {
+						return Promise.reject(error);
+					}
+				},
+				serviceBaseUrl: (serviceName) => {
+					if (!services.has(serviceName)) throw new ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.services.resolveBaseUrl(serviceName);
+				},
+				connection: (serviceName) => {
+					if (!services.has(serviceName)) throw new ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.connection(serviceName);
+				},
+				manage: (resource) => {
+					this.#deps.assertActive(`зарегистрировать ресурс feature «${name}»`);
+					if (controller.signal.aborted) throw new ItdStateError(`feature «${name}» не активен`);
+					const unregister = this.#deps.manage(resource);
+					let registered = true;
+					const release = () => {
+						if (!registered) return;
+						registered = false;
+						unregister();
+					};
+					if (!committed) rollback.push(() => {
+						if (!registered) return;
+						if (committed) {
+							release();
+							return;
+						}
+						try {
+							resource.stop();
+						} catch (error) {
+							reportRollbackError(`Не удалось остановить ресурс «${resource.kind}» при откате feature «${name}»`, error);
+						} finally {
+							release();
+						}
+						Promise.resolve().then(() => resource.drain()).catch((error) => {
+							reportRollbackError(`Не удалось освободить ресурс «${resource.kind}» при откате feature «${name}»`, error);
+						});
+					});
+					return release;
+				},
+				assertActive: (action) => {
+					this.#deps.assertActive(action);
+					if (!committed || controller.signal.aborted) throw new ItdStateError(`feature «${name}» не активен`);
+				}
+			});
+			const installation = feature.setup(context);
+			if (typeof installation !== "object" || installation === null || !("api" in installation)) throw new ItdConfigError(`setup() feature «${name}» должен вернуть объект с полем api`);
+			if (installation.close !== void 0 && typeof installation.close !== "function") throw new ItdConfigError(`feature «${name}»: close должен быть функцией`);
+			if (installation.dispose !== void 0 && typeof installation.dispose !== "function") throw new ItdConfigError(`feature «${name}»: dispose должен быть функцией`);
+			this.#features.set(name, {
+				name,
+				controller,
+				close: installation.close,
+				dispose: installation.dispose,
+				cleanup: [...rollback]
+			});
+			committed = true;
+			return installation.api;
+		} catch (error) {
+			controller.abort(new ItdAbortError(`Установка feature «${name}» отменена`));
+			for (const undo of rollback.reverse()) undo();
+			throw error;
+		}
+	}
+	names() {
+		return [...this.#features.keys()];
+	}
+	has(name) {
+		return this.#features.has(name);
+	}
+	async close() {
+		const errors = (await Promise.allSettled([...this.#features.values()].reverse().map(async (feature) => feature.close?.()))).filter((result) => result.status === "rejected").map((result) => result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось закрыть feature");
+	}
+	async dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		const errors = [];
+		const disposals = [];
+		const features = [...this.#features.values()].reverse();
+		for (const feature of features) {
+			feature.controller.abort(new ItdAbortError(`Feature «${feature.name}» освобождён`));
+			try {
+				disposals.push(Promise.resolve(feature.dispose?.()).then(() => void 0));
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		for (const feature of features) for (const cleanup of [...feature.cleanup].reverse()) try {
+			cleanup();
+		} catch (error) {
+			errors.push(error);
+		}
+		this.#features.clear();
+		const results = await Promise.allSettled(disposals);
+		for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить feature");
+	}
+};
+//#endregion
+//#region src/core/managed-resources.ts
+/** Реестр активных ресурсов клиента. @internal */
+var ManagedResourceRegistry = class {
+	#resources = /* @__PURE__ */ new Set();
+	#disposed = false;
+	register(resource) {
+		if (this.#disposed) throw new ItdStateError("Lifecycle клиента уже освобождён");
+		if (typeof resource !== "object" || resource === null || typeof resource.kind !== "string" || resource.kind.trim() === "" || typeof resource.stop !== "function" || typeof resource.drain !== "function") throw new ItdConfigError("Managed resource должен предоставлять kind, stop() и drain()");
+		this.#resources.add(resource);
+		let registered = true;
+		return () => {
+			if (!registered) return;
+			registered = false;
+			this.#resources.delete(resource);
+		};
+	}
+	/** Останавливает snapshot синхронно, чтобы новые auth-данные ещё не были опубликованы. */
+	stopAll() {
+		const resources = [...this.#resources];
+		const errors = [];
+		for (const resource of resources) try {
+			resource.stop();
+		} catch (error) {
+			errors.push(error);
+		}
+		return {
+			resources,
+			errors
+		};
+	}
+	dispose() {
+		this.#disposed = true;
+		this.#resources.clear();
+	}
+};
+//#endregion
+//#region src/core/feature-host.ts
+/**
+* Управляет подключаемыми модулями и их ресурсами.
+*
+* @internal
+*/
+var ClientFeatureHost = class {
+	#runtime;
+	#features;
+	#resources = new ManagedResourceRegistry();
+	/** Общий файловый порт ресурсов и подключаемых модулей этого клиента. @internal */
+	files;
+	constructor(runtime, options) {
+		this.#runtime = runtime;
+		this.files = createFileResolver(runtime.config.fetch);
+		this.#features = new FeatureRegistry({
+			http: runtime.http,
+			services: runtime.services,
+			serviceOverrides: runtime.config.services,
+			catalog: options.catalog,
+			baseUrl: runtime.config.baseUrl,
+			clock: runtime.config.clock,
+			logger: runtime.config.logger,
+			files: this.files,
+			assertActive: options.assertActive,
+			connection: (serviceName) => runtime.connection(serviceName),
+			manage: (resource) => this.#resources.register(resource),
+			registerBucket: (name, definition) => runtime.registerRateLimitBucket(name, definition)
+		});
+	}
+	install(feature) {
+		return this.#features.install(feature);
+	}
+	names() {
+		return this.#features.names();
+	}
+	has(name) {
+		return this.#features.has(name);
+	}
+	/** Регистрирует ресурс самого клиента. @internal */
+	manage(resource) {
+		return this.#resources.register(resource);
+	}
+	/** Останавливает ресурсы перед сменой авторизации. */
+	stop() {
+		const { errors } = this.#resources.stopAll();
+		if (errors.length > 0) this.#runtime.config.logger?.error("Не удалось остановить ресурсы клиента", errors);
+	}
+	/** Останавливает ресурсы и ждёт функции закрытия модулей. */
+	async close() {
+		const snapshot = this.#resources.stopAll();
+		const errors = [...snapshot.errors];
+		const deadline = createDeadline(this.#runtime.config.shutdownTimeout, this.#runtime.config.clock);
+		const tasks = [...snapshot.resources.map((resource) => ({
+			kind: resource.kind,
+			promise: Promise.resolve().then(() => resource.drain())
+		})), {
+			kind: "feature lifecycle",
+			promise: Promise.resolve().then(() => this.#features.close())
+		}];
+		try {
+			const stuck = (await Promise.all(tasks.map(async ({ kind, promise }) => {
+				const result = promise.catch((error) => {
+					errors.push(error);
+				});
+				return await deadline.wait(result) ? void 0 : kind;
+			}))).filter((kind) => kind !== void 0);
+			if (stuck.length > 0) errors.push(new ItdStateError(`ресурсы (${stuck.join(", ")}) не завершились за ${this.#runtime.config.shutdownTimeout} мс`));
+		} finally {
+			deadline.cancel();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Не удалось закрыть feature-host");
+	}
+	async dispose() {
+		this.#resources.dispose();
+		const deadline = createDeadline(this.#runtime.config.shutdownTimeout, this.#runtime.config.clock);
+		let failed = false;
+		let failure;
+		const settled = this.#features.dispose().catch((error) => {
+			failed = true;
+			failure = error;
+		});
+		try {
+			if (!await deadline.wait(settled)) throw new ItdStateError(`освобождение подключаемых модулей не завершилось за ${this.#runtime.config.shutdownTimeout} мс`);
+		} finally {
+			deadline.cancel();
+		}
+		if (failed) throw failure;
+	}
+};
+function createFeatureHost(runtime, options) {
+	return new ClientFeatureHost(runtime, options);
+}
+//#endregion
 //#region src/resources/pagination.ts
 /** Схема пагинации эндпоинта. */
 const PaginationMode = Object.freeze({
@@ -119,6 +864,10 @@ function readOffsetPage(body, field, offset) {
 		raw: body
 	};
 }
+/** Создаёт единый контракт пагинированной операции. */
+function pageOperation(id, read) {
+	return defineBuiltInOperation(id, read);
+}
 /**
 * Перебор страниц списка.
 *
@@ -244,6 +993,10 @@ var BaseResource = class {
 	constructor(http) {
 		this.http = http;
 	}
+	/** Выполняет операцию без возвращаемого значения и отбрасывает служебное тело ответа. */
+	voidOperation(operation, options) {
+		return this.http.execute(operation, options);
+	}
 	/**
 	* Собирает перебор страниц.
 	*
@@ -261,53 +1014,287 @@ var BaseResource = class {
 		});
 	}
 	/**
-	* Собирает пару «загрузка страницы + перебор» из одного описания.
+	* Собирает пару «загрузка страницы + перебор» из одного описания.
+	*
+	* Путь, параметры запроса и разбор ответа задаются один раз; `list` и `iterate`
+	* строятся из них.
+	*
+	* @example
+	* ```ts
+	* #feed = this.paginated<Post, FeedParams>({
+	*   operation: POSTS_LIST,
+	*   path: () => '/api/posts',
+	*   query: (p) => ({ tab: p.tab, limit: p.limit }),
+	*   start: (p) => (p.cursor ? { cursor: p.cursor } : {}),
+	*   mode: PaginationMode.Cursor,
+	* });
+	* ```
+	*/
+	paginated(spec) {
+		const load = async (params, state, options = {}) => {
+			const operation = typeof spec.operation === "function" ? spec.operation(params) : spec.operation;
+			return this.http.execute(operation, {
+				path: spec.path(params),
+				query: withPageState(spec.query(params), state),
+				...options
+			});
+		};
+		return {
+			list: (params, options) => load(params, spec.start(params), options),
+			iterate: (params, options = {}) => {
+				const { maxPages, ...requestOptions } = options;
+				return this.paginate(spec.mode, (state) => load(params, state, requestOptions), {
+					...maxPages !== void 0 ? { maxPages } : {},
+					...requestOptions.signal !== void 0 ? { signal: requestOptions.signal } : {},
+					start: spec.start(params)
+				});
+			}
+		};
+	}
+};
+/** Добавляет позицию страницы в параметры запроса. */
+function withPageState(query, state) {
+	return {
+		...query,
+		...state.cursor !== void 0 ? { cursor: state.cursor } : {},
+		...state.page !== void 0 ? { page: state.page } : {},
+		...state.offset !== void 0 ? { offset: state.offset } : {}
+	};
+}
+//#endregion
+//#region src/resources/notifications.ts
+const NOTIFICATIONS_LIST = pageOperation("notifications.list", (body, request) => {
+	const offset = Number(request.query?.offset ?? 0);
+	const page = readOffsetPage(body, "notifications", Number.isFinite(offset) ? offset : 0);
+	return {
+		...page,
+		items: page.items.map(normalizeNotification)
+	};
+});
+const NOTIFICATIONS_COUNT = defineBuiltInOperation("notifications.count", (body) => pickNumber(body, "count", 0));
+const markedCountOperation = (id) => defineBuiltInOperation(id, (body) => pickNumber(body, "markedCount", 0));
+const NOTIFICATIONS_MARK_READ = markedCountOperation("notifications.markRead");
+const NOTIFICATIONS_MARK_READ_BATCH = markedCountOperation("notifications.markReadBatch");
+const NOTIFICATIONS_MARK_ALL_READ = markedCountOperation("notifications.markAllRead");
+const NOTIFICATIONS_GET_SETTINGS = defineBuiltInOperation("notifications.getSettings", readSettings);
+const NOTIFICATIONS_UPDATE_SETTINGS = defineBuiltInOperation("notifications.updateSettings", readSettings);
+const NOTIFICATION_SETTING_KEYS = [
+	"enabled",
+	"sound",
+	"follows",
+	"wallPosts",
+	"likes",
+	"comments",
+	"mentions"
+];
+/**
+* Сколько идентификаторов уходит в одном запросе на отметку прочтения.
+*
+* Столько же отправляет сайт итд.com — значит на сервере, скорее всего, есть ограничение.
+*/
+const READ_BATCH_SIZE = 20;
+/**
+* Читает настройки уведомлений.
+*
+* Сервер отдаёт плоский объект: `enabled`, `sound`, `follows`, `wallPosts`, `likes`,
+* `comments`, `mentions`. Отсутствующая настройка считается включённой — так же
+* ведёт себя сайт итд.com.
+*/
+function readSettings(body) {
+	const settings = {};
+	for (const key of NOTIFICATION_SETTING_KEYS) settings[key] = pickBoolean(body, key, true);
+	return settings;
+}
+/**
+* Уведомления: список, счётчик, отметки о прочтении, настройки.
+*
+* Доступна как `itd.notifications`. Все уведомления приведены к единой форме, поэтому
+* объекты отсюда и из потока событий можно складывать в один список.
+*/
+var NotificationsResource = class extends BaseResource {
+	/** Уведомления: `/api/notifications/`, пагинация по смещению. */
+	#list = this.paginated({
+		operation: NOTIFICATIONS_LIST,
+		path: () => "/api/notifications/",
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => ({ offset: p.offset ?? 0 }),
+		mode: PaginationMode.Offset
+	});
+	/**
+	* Загружает страницу уведомлений.
+	*
+	* Пагинация здесь основана на смещении.
+	*
+	* @example
+	* ```ts
+	* const page = await itd.notifications.list({ limit: 20 });
+	* const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
+	* ```
+	*/
+	list(params = {}, options = {}) {
+		return this.#list.list(params, options);
+	}
+	/**
+	* Перебирает уведомления.
+	*
+	* @example
+	* ```ts
+	* for await (const notification of itd.notifications.iterate()) {
+	*   console.log(formatNotificationText(notification));
+	* }
+	* ```
+	*/
+	iterate(params = {}, options = {}) {
+		return this.#list.iterate(params, options);
+	}
+	/** Загружает число непрочитанных уведомлений. */
+	count(options = {}) {
+		return this.http.execute(NOTIFICATIONS_COUNT, {
+			path: "/api/notifications/count",
+			...options
+		});
+	}
+	/**
+	* Отмечает уведомление прочитанным.
+	*
+	* @returns сколько записей отметил сервер
+	*/
+	markRead(notificationId, options = {}) {
+		return this.http.execute(NOTIFICATIONS_MARK_READ, {
+			path: `/api/notifications/${encodePathSegment(notificationId, "notificationId")}/read`,
+			...options
+		});
+	}
+	/**
+	* Отмечает прочитанными сразу несколько уведомлений.
 	*
-	* Путь, параметры запроса и разбор ответа задаются один раз; `list` и `iterate`
-	* строятся из них.
+	* Список автоматически режется на части по 20 идентификаторов — столько же отправляет
+	* сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
+	* результат суммируется.
 	*
-	* @example
-	* ```ts
-	* #feed = this.paginated<Post, FeedParams>({
-	*   operationId: 'posts.list',
-	*   path: () => '/api/posts',
-	*   query: (p) => ({ tab: p.tab, limit: p.limit }),
-	*   start: (p) => (p.cursor ? { cursor: p.cursor } : {}),
-	*   read: (body) => readCursorPage<Post>(body, 'posts'),
-	*   mode: PaginationMode.Cursor,
-	* });
-	* ```
+	* @returns сколько записей отметил сервер суммарно
 	*/
-	paginated(spec) {
-		const load = async (params, state, options = {}) => {
-			const operationId = typeof spec.operationId === "function" ? spec.operationId(params) : spec.operationId;
-			const body = await this.http.operation(operationId, {
-				path: spec.path(params),
-				query: withPageState(spec.query(params), state),
+	async markReadBatch(ids, options = {}) {
+		let marked = 0;
+		for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
+			const chunk = ids.slice(index, index + READ_BATCH_SIZE);
+			marked += await this.http.execute(NOTIFICATIONS_MARK_READ_BATCH, {
+				path: "/api/notifications/read-batch",
+				body: { ids: chunk },
 				...options
 			});
-			return spec.read(body, state);
-		};
-		return {
-			list: (params, options) => load(params, spec.start(params), options),
-			iterate: (params, options = {}) => {
-				const { maxPages, ...requestOptions } = options;
-				return this.paginate(spec.mode, (state) => load(params, state, requestOptions), {
-					...maxPages !== void 0 ? { maxPages } : {},
-					...requestOptions.signal !== void 0 ? { signal: requestOptions.signal } : {},
-					start: spec.start(params)
-				});
-			}
-		};
+		}
+		return marked;
+	}
+	/** Отмечает прочитанными все уведомления. */
+	markAllRead(options = {}) {
+		return this.http.execute(NOTIFICATIONS_MARK_ALL_READ, {
+			path: "/api/notifications/read-all",
+			...options
+		});
+	}
+	/** Загружает настройки уведомлений. */
+	getSettings(options = {}) {
+		return this.http.execute(NOTIFICATIONS_GET_SETTINGS, {
+			path: "/api/notifications/settings",
+			...options
+		});
+	}
+	/**
+	* Обновляет настройки уведомлений.
+	*
+	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
+	*/
+	async updateSettings(input, options = {}) {
+		const payload = {};
+		for (const key of NOTIFICATION_SETTING_KEYS) {
+			const value = input[key];
+			if (value !== void 0) payload[key] = value;
+		}
+		return this.http.execute(NOTIFICATIONS_UPDATE_SETTINGS, {
+			path: "/api/notifications/settings",
+			body: payload,
+			...options
+		});
 	}
 };
-/** Добавляет позицию страницы в параметры запроса. */
-function withPageState(query, state) {
+//#endregion
+//#region src/domain/time.ts
+const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+/**
+* Приводит отметку времени без часового пояса к ISO-8601, считая её временем UTC.
+*
+* Строку другого вида возвращает нетронутой.
+*
+* @example
+* ```ts
+* utcStampToIso('2026-07-23 23:14:25');  // '2026-07-23T23:14:25Z'
+* utcStampToIso('2026-07-23T23:14:25Z'); // без изменений
+* ```
+*/
+function utcStampToIso(value) {
+	const match = typeof value === "string" ? NAIVE_STAMP.exec(value) : null;
+	if (!match) return 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/status.ts
+/** Приводит `last_checked` каждого сервиса к ISO. Остальное остаётся как прислал сервер. */
+function normalizeStatus(body) {
+	if (!isRecord(body) || !Array.isArray(body.services)) return body;
 	return {
-		...query,
-		...state.cursor !== void 0 ? { cursor: state.cursor } : {},
-		...state.page !== void 0 ? { page: state.page } : {},
-		...state.offset !== void 0 ? { offset: state.offset } : {}
+		...body,
+		services: body.services.map((service) => typeof service?.last_checked === "string" ? {
+			...service,
+			last_checked: utcStampToIso(service.last_checked)
+		} : service)
+	};
+}
+/** API встроенного status feature. @internal */
+var StatusResource = class {
+	#context;
+	constructor(context) {
+		this.#context = context;
+	}
+	get(options = {}) {
+		return this.#context.request("get", {
+			path: "/api/status",
+			...options
+		});
+	}
+};
+/** Встроенный модуль страницы состояния платформы. @internal */
+function createStatusFeature() {
+	return {
+		name: "status",
+		services: [{
+			name: STATUS_SERVICE,
+			baseUrl: DEFAULT_STATUS_BASE_URL,
+			auth: false
+		}],
+		operations: { get: {
+			method: "GET",
+			retrySafety: RetrySafety.Safe,
+			service: STATUS_SERVICE,
+			read: (body) => normalizeStatus(body)
+		} },
+		setup: (context) => ({ api: new StatusResource(context) })
 	};
 }
 //#endregion
@@ -470,6 +1457,13 @@ function resolveComment(input, allowReplyTo = false) {
 }
 //#endregion
 //#region src/resources/comments.ts
+const COMMENTS_REPLIES = pageOperation("comments.replies", (body) => readPagedPage(body, "replies"));
+const COMMENTS_REPLY = passthroughOperation("comments.reply");
+const COMMENTS_UPDATE = passthroughOperation("comments.update");
+const COMMENTS_RESTORE = passthroughOperation("comments.restore");
+const COMMENTS_LIKE = passthroughOperation("comments.like");
+const COMMENTS_UNLIKE = passthroughOperation("comments.unlike");
+const COMMENTS_REMOVE = voidOperation("comments.remove");
 /**
 * Комментарии и ответы на них.
 *
@@ -480,11 +1474,10 @@ var CommentsResource = class extends BaseResource {
 	#uploadFiles;
 	/** Ответы на комментарий: `/api/comments/{id}/replies`, постраничная пагинация. */
 	#replies = this.paginated({
-		operationId: "comments.replies",
+		operation: COMMENTS_REPLIES,
 		path: (p) => `/api/comments/${encodePathSegment(p.commentId, "commentId")}/replies`,
 		query: (p) => ({ limit: p.limit }),
 		start: (p) => p.page !== void 0 ? { page: p.page } : {},
-		read: (body) => readPagedPage(body, "replies"),
 		mode: PaginationMode.Page
 	});
 	constructor(http, deps) {
@@ -523,7 +1516,7 @@ var CommentsResource = class extends BaseResource {
 		const existing = data.attachmentIds ?? [];
 		const files = data.files ?? [];
 		const attachmentIds = files.length > 0 ? [...existing, ...await this.#uploadFiles(files, options)] : existing;
-		return this.http.operation("comments.reply", {
+		return this.http.execute(COMMENTS_REPLY, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/replies`,
 			body: {
 				content: data.content ?? "",
@@ -535,7 +1528,7 @@ var CommentsResource = class extends BaseResource {
 	}
 	/** Редактирует текст комментария. */
 	update(commentId, content, options = {}) {
-		return this.http.operation("comments.update", {
+		return this.http.execute(COMMENTS_UPDATE, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
 			body: { content },
 			...options
@@ -543,167 +1536,33 @@ var CommentsResource = class extends BaseResource {
 	}
 	/** Удаляет комментарий. Восстановить его можно через {@link restore}. */
 	remove(commentId, options = {}) {
-		return this.http.operation("comments.remove", {
+		return this.voidOperation(COMMENTS_REMOVE, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый комментарий. */
 	restore(commentId, options = {}) {
-		return this.http.operation("comments.restore", {
+		return this.http.execute(COMMENTS_RESTORE, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на комментарий. */
 	like(commentId, options = {}) {
-		return this.http.operation("comments.like", {
+		return this.http.execute(COMMENTS_LIKE, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с комментария. */
 	unlike(commentId, options = {}) {
-		return this.http.operation("comments.unlike", {
+		return this.http.execute(COMMENTS_UNLIKE, {
 			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
 			...options
-		});
-	}
-};
-//#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 fileTooLarge(url, maxBytes, size);
-	return size;
-}
-/** Получает HTTP-ответ источника и проверяет его статус. */
-async function fetchFile(target, options, context) {
-	let requested;
-	try {
-		requested = new URL(target);
-	} catch {
-		throw new ItdConfigError(`«${target}» не разбирается как адрес`);
-	}
-	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new 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 ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
-			reason: 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 ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
-			reason: ItdFileErrorReason.Http,
-			url: finalUrl.href,
-			status: response.status,
-			retryable: response.status === 408 || response.status === 429 || response.status >= 500
-		});
-	}
-	const { maxBytes } = resolveFileStreamOptions(options, 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 fileTooLarge(url, maxBytes, blob.size);
-		return blob;
-	}
-	const chunks = [];
-	const reader = 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 = resolveFileStreamOptions(options, 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 = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
-	const { response, url, size } = await fetchFile(target, options, context);
-	if (!response.body) throw new ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
-		reason: ItdFileErrorReason.StreamUnavailable,
-		url: url.href
-	});
-	const stream = 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/multipart.ts
 const encoder = new TextEncoder();
@@ -841,12 +1700,17 @@ function assertAllowedMime(mimeType, filename) {
 	if (!mimeType) throw new ItdConfigError(`Не удалось определить тип файла${filename ? ` «${filename}»` : ""}. Укажите его явно: { file, filename, contentType }.`);
 	if (!isAllowedMime(mimeType)) throw new ItdConfigError(`Тип «${mimeType}» не поддерживается загрузкой. Допустимые: ${ALLOWED_MIME_TYPES.join(", ")}.`);
 }
+//#endregion
+//#region src/resources/files.ts
+const FILES_UPLOAD = passthroughOperation("files.upload");
+const FILES_GET = passthroughOperation("files.get");
+const FILES_REMOVE = voidOperation("files.remove");
 /** Файлы и медиа. */
 var FilesResource = class extends BaseResource {
-	#fetch;
+	#files;
 	constructor(http, deps) {
 		super(http);
-		this.#fetch = deps.fetch;
+		this.#files = deps.files;
 	}
 	/**
 	* Загружает файл и возвращает его идентификатор.
@@ -856,7 +1720,7 @@ var FilesResource = class extends BaseResource {
 	*/
 	upload(input, uploadOptions = {}, requestOptions = {}) {
 		const bodyFactory = this.#createBodyFactory(input, uploadOptions);
-		return this.http.operation("files.upload", {
+		return this.http.execute(FILES_UPLOAD, {
 			path: "/api/files/upload",
 			bodyFactory,
 			...requestOptions,
@@ -875,14 +1739,14 @@ var FilesResource = class extends BaseResource {
 	* Для ещё не прикреплённого файла сервер может ответить `404`.
 	*/
 	get(fileId, options = {}) {
-		return this.http.operation("files.get", {
+		return this.http.execute(FILES_GET, {
 			path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
 			...options
 		});
 	}
 	/** Удаляет загруженный файл. */
 	remove(fileId, options = {}) {
-		return this.http.operation("files.remove", {
+		return this.voidOperation(FILES_REMOVE, {
 			path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
 			...options
 		});
@@ -892,140 +1756,70 @@ var FilesResource = class extends BaseResource {
 	* заново, поэтому каждая транспортная попытка получает непрочитанное тело.
 	*/
 	#createBodyFactory(input, options) {
-		const streamMode = this.#isStreamInput(input);
+		const streamMode = this.#files.mode(input) === FileTransferMode.Stream;
 		let buffered;
 		return async ({ signal, attempt }) => {
-			const context = {
-				fetch: this.#fetch,
+			let prepared;
+			if (streamMode) prepared = await this.#files.resolve(input, options, {
 				signal,
 				attempt
-			};
-			let prepared;
-			try {
-				if (streamMode) prepared = await this.#prepareStream(input, options, context);
-				else {
-					buffered ??= this.#prepareBuffer(input, options, context).catch((error) => {
-						buffered = void 0;
-						throw error;
-					});
-					prepared = await buffered;
-				}
-			} catch (error) {
-				if (error instanceof ItdError || signal.aborted) throw error;
-				throw new ItdFileError("не удалось получить содержимое вложения", {
-					reason: ItdFileErrorReason.Read,
-					retryable: true,
-					cause: error
+			});
+			else {
+				buffered ??= this.#files.resolve(input, options, {
+					signal,
+					attempt
+				}).then((source) => source).catch((error) => {
+					buffered = void 0;
+					throw error;
 				});
+				prepared = await buffered;
 			}
-			if (prepared.mode === "buffer") {
+			if (prepared.mode === FileTransferMode.Buffer) {
+				const filename = this.#filename(prepared, options);
+				const contentType = prepared.contentType ?? mimeFromFilename(filename);
+				if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+				const blob = !contentType || prepared.blob.type === contentType ? prepared.blob : new Blob([prepared.blob], { type: contentType });
 				const form = new FormData();
-				form.set("file", prepared.blob, prepared.filename);
+				form.set("file", blob, filename);
 				return { body: form };
 			}
-			const multipart = createMultipartFileBody(prepared);
-			return {
-				body: multipart.body,
-				headers: { "Content-Type": multipart.contentType },
-				cleanup: async () => {
-					await multipart.cancel();
-					await prepared.close?.();
-				}
-			};
-		};
-	}
-	/** Определяет режим без чтения источника. */
-	#isStreamInput(input) {
-		if (typeof input !== "object" || input === null) return false;
-		if ("open" in input) return true;
-		if ("url" in input) return resolveFileStreamOptions(input).mode === FileTransferMode.Stream;
-		return false;
-	}
-	/** Получает и проверяет буферный источник. */
-	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 = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
-		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
-		const blob = isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
-		const limits = resolveFileStreamOptions(options);
-		if (limits.maxBytes !== void 0 && blob.size > limits.maxBytes) throw new ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${blob.size}`, {
-			reason: ItdFileErrorReason.TooLarge,
-			limit: limits.maxBytes,
-			actual: blob.size
-		});
-		return {
-			mode: "buffer",
-			blob,
-			filename
-		};
-	}
-	/** Открывает и проверяет потоковый источник. */
-	async #prepareStream(input, options, context) {
-		let opened;
-		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 openUrlFile(url, urlOptions, context);
-		} else throw new ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
-		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
-			await opened?.close?.();
-			throw new ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
-		}
-		try {
-			const filename = options.filename ?? opened.filename ?? this.#nameFromMime(options.contentType ?? opened.contentType);
-			const contentType = normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
-			if (options.validateMime !== false) assertAllowedMime(contentType, filename);
-			const limits = resolveFileStreamOptions({
-				mode: FileTransferMode.Stream,
-				...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
-				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
-			});
-			if (limits.maxBytes !== void 0 && opened.size !== void 0 && opened.size > limits.maxBytes) throw new ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${opened.size}`, {
-				reason: ItdFileErrorReason.TooLarge,
-				limit: limits.maxBytes,
-				actual: opened.size
-			});
-			return {
-				mode: "stream",
-				stream: isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : boundedFileStream(opened.stream, {
-					...limits.maxBytes !== void 0 ? { maxBytes: limits.maxBytes } : {},
-					streamBufferBytes: limits.streamBufferBytes,
-					signal: context.signal
-				}),
-				filename,
-				contentType: contentType ?? "",
-				...opened.close ? { close: opened.close } : {}
-			};
-		} catch (error) {
-			await opened.close?.();
-			throw error;
-		}
-	}
-	/** Разрешает только буферные формы. */
-	#resolveBuffer(input, context) {
-		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || isBlob(input)) return {
-			file: input,
-			...isFile(input) ? { filename: input.name } : {}
+			let multipart;
+			try {
+				const filename = this.#filename(prepared, options);
+				const contentType = prepared.contentType ?? mimeFromFilename(filename);
+				if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+				multipart = createMultipartFileBody({
+					stream: prepared.stream,
+					filename,
+					contentType: contentType ?? ""
+				});
+				return {
+					body: multipart.body,
+					headers: { "Content-Type": multipart.contentType },
+					cleanup: async () => {
+						await multipart?.cancel();
+						await prepared.close();
+					}
+				};
+			} catch (error) {
+				await prepared.close();
+				throw error;
+			}
 		};
-		if (typeof input !== "object" || input === null) throw new ItdConfigError(`вложение задано значением типа ${typeof input}; ожидается бинарное значение или объект { file }, { url }, { load }, { open }. Для файла на диске используйте fromPath('./photo.jpg') из itd-api/node`);
-		if ("load" in input) return input.load(context);
-		if ("url" in input) {
-			const { url, ...urlOptions } = input;
-			return downloadFile(url, urlOptions, context);
-		}
-		if ("file" in input) return input;
-		if ("open" in input) throw new ItdConfigError("потоковый источник нельзя использовать как буферный");
-		throw new ItdConfigError("вложение не распознано: ожидается { file }, { url }, { load } или { open }");
 	}
 	/** Подбирает непустое имя, обязательное для multipart. */
-	#nameFromMime(contentType) {
-		const extension = normalizeMimeType(contentType)?.split("/")[1];
+	#filename(source, options) {
+		if (options.filename) return options.filename;
+		if (source.filename) return source.filename;
+		const extension = options.contentType?.split(";", 1)[0]?.trim().split("/")[1];
 		return extension ? `file.${extension}` : "file";
 	}
 };
 //#endregion
 //#region src/resources/hashtags.ts
+const HASHTAG_POSTS = pageOperation("hashtags.posts", (body) => readCursorPage(body, "posts"));
+const HASHTAGS_SEARCH = defineBuiltInOperation("hashtags.search", (body) => pickArray(body, "hashtags"));
+const HASHTAGS_TRENDING = defineBuiltInOperation("hashtags.trending", (body) => pickArray(body, "hashtags"));
 /**
 * Хэштеги.
 *
@@ -1034,11 +1828,10 @@ var FilesResource = class extends BaseResource {
 var HashtagsResource = class extends BaseResource {
 	/** Посты по хэштегу: `/api/hashtags/{tag}/posts`, курсорная пагинация. */
 	#posts = this.paginated({
-		operationId: "hashtags.posts",
+		operation: HASHTAG_POSTS,
 		path: (p) => `/api/hashtags/${encodePathSegment(p.tag, "tag")}/posts`,
 		query: (p) => ({ limit: p.limit }),
 		start: (p) => p.cursor ? { cursor: p.cursor } : {},
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/**
@@ -1046,8 +1839,8 @@ var HashtagsResource = class extends BaseResource {
 	*
 	* Без строки запроса возвращает общий список.
 	*/
-	async search(query, params = {}, options = {}) {
-		const body = await this.http.operation("hashtags.search", {
+	search(query, params = {}, options = {}) {
+		return this.http.execute(HASHTAGS_SEARCH, {
 			path: "/api/hashtags",
 			query: {
 				q: query,
@@ -1055,16 +1848,14 @@ var HashtagsResource = class extends BaseResource {
 			},
 			...options
 		});
-		return pickArray(body, "hashtags");
 	}
 	/** Загружает трендовые хэштеги. */
-	async trending(params = {}, options = {}) {
-		const body = await this.http.operation("hashtags.trending", {
+	trending(params = {}, options = {}) {
+		return this.http.execute(HASHTAGS_TRENDING, {
 			path: "/api/hashtags/trending",
 			query: { limit: params.limit },
 			...options
 		});
-		return pickArray(body, "hashtags");
 	}
 	/**
 	* Загружает страницу постов по хэштегу.
@@ -1087,212 +1878,23 @@ var HashtagsResource = class extends BaseResource {
 	}
 };
 //#endregion
-//#region src/resources/notifications.ts
-const NOTIFICATION_SETTING_KEYS = [
-	"enabled",
-	"sound",
-	"follows",
-	"wallPosts",
-	"likes",
-	"comments",
-	"mentions"
-];
-/**
-* Сколько идентификаторов уходит в одном запросе на отметку прочтения.
-*
-* Столько же отправляет сайт итд.com — значит на сервере, скорее всего, есть ограничение.
-*/
-const READ_BATCH_SIZE = 20;
-/**
-* Читает настройки уведомлений.
-*
-* Сервер отдаёт плоский объект: `enabled`, `sound`, `follows`, `wallPosts`, `likes`,
-* `comments`, `mentions`. Отсутствующая настройка считается включённой — так же
-* ведёт себя сайт итд.com.
-*/
-function readSettings(body) {
-	const settings = {};
-	for (const key of NOTIFICATION_SETTING_KEYS) settings[key] = pickBoolean(body, key, true);
-	return settings;
-}
-/**
-* Уведомления: список, счётчик, отметки о прочтении, настройки.
-*
-* Доступна как `itd.notifications`. Все уведомления приведены к единой форме, поэтому
-* объекты отсюда и из потока событий можно складывать в один список.
-*/
-var NotificationsResource = class extends BaseResource {
-	/** Уведомления: `/api/notifications/`, пагинация по смещению. */
-	#list = this.paginated({
-		operationId: "notifications.list",
-		path: () => "/api/notifications/",
-		query: (p) => ({ limit: p.limit }),
-		start: (p) => ({ offset: p.offset ?? 0 }),
-		read: (body, state) => {
-			const page = readOffsetPage(body, "notifications", state.offset ?? 0);
-			return {
-				...page,
-				items: page.items.map(normalizeNotification)
-			};
-		},
-		mode: PaginationMode.Offset
-	});
-	/**
-	* Загружает страницу уведомлений.
-	*
-	* Пагинация здесь основана на смещении.
-	*
-	* @example
-	* ```ts
-	* const page = await itd.notifications.list({ limit: 20 });
-	* const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
-	* ```
-	*/
-	list(params = {}, options = {}) {
-		return this.#list.list(params, options);
-	}
-	/**
-	* Перебирает уведомления.
-	*
-	* @example
-	* ```ts
-	* for await (const notification of itd.notifications.iterate()) {
-	*   console.log(formatNotificationText(notification));
-	* }
-	* ```
-	*/
-	iterate(params = {}, options = {}) {
-		return this.#list.iterate(params, options);
-	}
-	/** Загружает число непрочитанных уведомлений. */
-	async count(options = {}) {
-		const body = await this.http.operation("notifications.count", {
-			path: "/api/notifications/count",
-			...options
-		});
-		return pickNumber(body, "count", 0);
-	}
-	/**
-	* Отмечает уведомление прочитанным.
-	*
-	* @returns сколько записей отметил сервер
-	*/
-	async markRead(notificationId, options = {}) {
-		const body = await this.http.operation("notifications.markRead", {
-			path: `/api/notifications/${encodePathSegment(notificationId, "notificationId")}/read`,
-			...options
-		});
-		return pickNumber(body, "markedCount", 0);
-	}
-	/**
-	* Отмечает прочитанными сразу несколько уведомлений.
-	*
-	* Список автоматически режется на части по 20 идентификаторов — столько же отправляет
-	* сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
-	* результат суммируется.
-	*
-	* @returns сколько записей отметил сервер суммарно
-	*/
-	async markReadBatch(ids, options = {}) {
-		let marked = 0;
-		for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
-			const chunk = ids.slice(index, index + READ_BATCH_SIZE);
-			const body = await this.http.operation("notifications.markReadBatch", {
-				path: "/api/notifications/read-batch",
-				body: { ids: chunk },
-				...options
-			});
-			marked += pickNumber(body, "markedCount", 0);
-		}
-		return marked;
-	}
-	/** Отмечает прочитанными все уведомления. */
-	async markAllRead(options = {}) {
-		const body = await this.http.operation("notifications.markAllRead", {
-			path: "/api/notifications/read-all",
-			...options
-		});
-		return pickNumber(body, "markedCount", 0);
-	}
-	/** Загружает настройки уведомлений. */
-	async getSettings(options = {}) {
-		return readSettings(await this.http.operation("notifications.getSettings", {
-			path: "/api/notifications/settings",
-			...options
-		}));
-	}
-	/**
-	* Обновляет настройки уведомлений.
-	*
-	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
-	*/
-	async updateSettings(input, options = {}) {
-		const payload = {};
-		for (const key of NOTIFICATION_SETTING_KEYS) {
-			const value = input[key];
-			if (value !== void 0) payload[key] = value;
-		}
-		return readSettings(await this.http.operation("notifications.updateSettings", {
-			path: "/api/notifications/settings",
-			body: payload,
-			...options
-		}));
-	}
-};
-//#endregion
-//#region src/domain/time.ts
-const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
-/**
-* Приводит отметку времени без часового пояса к ISO-8601, считая её временем UTC.
-*
-* Строку другого вида возвращает нетронутой.
-*
-* @example
-* ```ts
-* utcStampToIso('2026-07-23 23:14:25');  // '2026-07-23T23:14:25Z'
-* utcStampToIso('2026-07-23T23:14:25Z'); // без изменений
-* ```
-*/
-function utcStampToIso(value) {
-	const match = typeof value === "string" ? NAIVE_STAMP.exec(value) : null;
-	if (!match) return 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. Остальное остаётся как прислал сервер. */
-function normalizeStatus(body) {
-	if (!isRecord(body) || !Array.isArray(body.services)) return body;
-	return {
-		...body,
-		services: body.services.map((service) => typeof service?.last_checked === "string" ? {
-			...service,
-			last_checked: utcStampToIso(service.last_checked)
-		} : service)
-	};
-}
+const PLATFORM_CHANGELOG = defineBuiltInOperation("platform.changelog", (body) => Array.isArray(body) ? body : []);
+const PLATFORM_ANNOUNCEMENTS = defineBuiltInOperation("platform.announcements", (body) => pickArray(body, "announcements"));
+const PLATFORM_VERSION = passthroughOperation("platform.version");
+const PLATFORM_PORTAL = passthroughOperation("platform.portal");
 /**
 * Сведения о платформе: версии приложений, изменения, анонсы, баннер события.
 *
 * Доступна как `itd.platform`.
 */
 var PlatformResource = class extends BaseResource {
+	#status;
+	/** @internal */
+	constructor(http, status) {
+		super(http);
+		this.#status = status;
+	}
 	/**
 	* Загружает минимальные и актуальные версии клиентских приложений.
 	*
@@ -1305,31 +1907,29 @@ var PlatformResource = class extends BaseResource {
 	* ```
 	*/
 	version(options = {}) {
-		return this.http.operation("platform.version", {
+		return this.http.execute(PLATFORM_VERSION, {
 			path: "/api/platform/version",
 			skipAuth: true,
 			...options
 		});
 	}
 	/** Загружает журнал изменений. */
-	async changelog(options = {}) {
-		const body = await this.http.operation("platform.changelog", {
+	changelog(options = {}) {
+		return this.http.execute(PLATFORM_CHANGELOG, {
 			path: "/api/platform/changelog",
 			...options
 		});
-		return Array.isArray(body) ? body : [];
 	}
 	/** Загружает анонсы платформы. */
-	async announcements(options = {}) {
-		const body = await this.http.operation("platform.announcements", {
+	announcements(options = {}) {
+		return this.http.execute(PLATFORM_ANNOUNCEMENTS, {
 			path: "/api/platform/announcements",
 			...options
 		});
-		return pickArray(body, "announcements");
 	}
 	/** Загружает баннер текущего события — виджет «портал». */
 	portal(options = {}) {
-		return this.http.operation("platform.portal", {
+		return this.http.execute(PLATFORM_PORTAL, {
 			path: "/api/v1/portal",
 			...options
 		});
@@ -1351,11 +1951,7 @@ var PlatformResource = class extends BaseResource {
 	* ```
 	*/
 	async status(options = {}) {
-		return normalizeStatus(await this.http.operation("platform.status", {
-			service: STATUS_SERVICE,
-			path: "/api/status",
-			...options
-		}));
+		return this.#status.get(options);
 	}
 };
 //#endregion
@@ -2050,7 +2646,7 @@ function autoSpans(text, options = {}) {
 		});
 	}
 	if (includeLinks) spans.push(...links);
-	if (includeHashtags || includeMentions) for (const match of text.matchAll(/#([\p{L}\p{M}\p{N}_]+)|@([a-z\d][a-z\d._-]*)/giu)) {
+	if (includeHashtags || includeMentions) for (const match of text.matchAll(/#([\p{L}\p{M}\p{N}_]+)|@([a-z\d](?:[a-z\d_]*[a-z\d])?)/giu)) {
 		if (match.index === void 0) continue;
 		const offset = match.index;
 		const previous = previousCodePoint(text, offset);
@@ -2058,7 +2654,7 @@ function autoSpans(text, options = {}) {
 		const end = offset + match[0].length;
 		if (links.some((span) => overlaps(span, offset, end))) continue;
 		const hashtag = match[1];
-		const username = match[2]?.replace(/[._-]+$/u, "");
+		const username = match[2];
 		if (hashtag !== void 0 && includeHashtags) spans.push({
 			type: SpanType.Hashtag,
 			offset,
@@ -2451,6 +3047,24 @@ function resolvePostUpdate(input) {
 }
 //#endregion
 //#region src/resources/posts.ts
+const POSTS_LIST = pageOperation("posts.list", (body) => readCursorPage(body, "posts"));
+const POSTS_BY_USER = pageOperation("posts.byUser", (body) => readCursorPage(body, "posts"));
+const POSTS_LIKED_BY_USER = pageOperation("posts.likedByUser", (body) => readCursorPage(body, "posts"));
+const POSTS_COMMENTS = pageOperation("posts.comments", (body) => readFlatCursorPage(body, "comments"));
+const POSTS_STATS = defineBuiltInOperation("posts.stats", (body) => pickArray(body, "posts"));
+const POSTS_CREATE = passthroughOperation("posts.create");
+const POSTS_GET = passthroughOperation("posts.get");
+const POSTS_UPDATE = passthroughOperation("posts.update");
+const POSTS_RESTORE = passthroughOperation("posts.restore");
+const POSTS_LIKE = passthroughOperation("posts.like");
+const POSTS_UNLIKE = passthroughOperation("posts.unlike");
+const POSTS_REPOST = passthroughOperation("posts.repost");
+const POSTS_PIN = passthroughOperation("posts.pin");
+const POSTS_UNPIN = passthroughOperation("posts.unpin");
+const POSTS_VOTE = passthroughOperation("posts.vote");
+const POSTS_COMMENT = passthroughOperation("posts.comment");
+const POSTS_REMOVE = voidOperation("posts.remove");
+const POSTS_UNREPOST = voidOperation("posts.unrepost");
 /** Курсорная позиция из параметров: если курсор задан — с него, иначе с начала. */
 function cursorStart(params) {
 	return params.cursor ? { cursor: params.cursor } : {};
@@ -2464,19 +3078,18 @@ var PostsResource = class extends BaseResource {
 	#uploadFiles;
 	/** Лента: `/api/posts`, курсорная пагинация. */
 	#feed = this.paginated({
-		operationId: "posts.list",
+		operation: POSTS_LIST,
 		path: () => "/api/posts",
 		query: (p) => ({
 			tab: p.tab,
 			limit: p.limit
 		}),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Стена пользователя: `/api/posts/user/{user}`. */
 	#wall = this.paginated({
-		operationId: "posts.byUser",
+		operation: POSTS_BY_USER,
 		path: (p) => `/api/posts/user/${encodePathSegment(p.user, "user")}`,
 		query: (p) => ({
 			limit: p.limit,
@@ -2484,28 +3097,25 @@ var PostsResource = class extends BaseResource {
 			pinnedPostId: p.pinnedPostId
 		}),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Понравившиеся посты пользователя: `/api/posts/user/{user}/liked`. */
 	#liked = this.paginated({
-		operationId: "posts.likedByUser",
+		operation: POSTS_LIKED_BY_USER,
 		path: (p) => `/api/posts/user/${encodePathSegment(p.user, "user")}/liked`,
 		query: (p) => ({ limit: p.limit }),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Комментарии к посту: курсор лежит рядом со списком, поэтому свой reader. */
 	#comments = this.paginated({
-		operationId: "posts.comments",
+		operation: POSTS_COMMENTS,
 		path: (p) => `/api/posts/${encodePathSegment(p.postId, "postId")}/comments`,
 		query: (p) => ({
 			limit: p.limit,
 			sort: p.sort
 		}),
 		start: cursorStart,
-		read: (body) => readFlatCursorPage(body, "comments"),
 		mode: PaginationMode.Cursor
 	});
 	constructor(http, deps) {
@@ -2552,7 +3162,7 @@ var PostsResource = class extends BaseResource {
 	async create(input, options = {}) {
 		const data = resolvePost(input);
 		const attachmentIds = await this.#collectAttachments(data, options);
-		return this.http.operation("posts.create", {
+		return this.http.execute(POSTS_CREATE, {
 			path: "/api/posts",
 			body: {
 				content: data.content ?? "",
@@ -2570,7 +3180,7 @@ var PostsResource = class extends BaseResource {
 	* В отличие от списков, здесь у поста заполнено поле `comments`.
 	*/
 	get(postId, options = {}) {
-		return this.http.operation("posts.get", {
+		return this.http.execute(POSTS_GET, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
 			...options
 		});
@@ -2584,7 +3194,7 @@ var PostsResource = class extends BaseResource {
 	*/
 	update(postId, input, options = {}) {
 		const data = resolvePostUpdate(input);
-		return this.http.operation("posts.update", {
+		return this.http.execute(POSTS_UPDATE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
 			body: {
 				content: data.content,
@@ -2595,28 +3205,28 @@ var PostsResource = class extends BaseResource {
 	}
 	/** Удаляет пост. Восстановить его можно через {@link restore}. */
 	remove(postId, options = {}) {
-		return this.http.operation("posts.remove", {
+		return this.voidOperation(POSTS_REMOVE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый пост. */
 	restore(postId, options = {}) {
-		return this.http.operation("posts.restore", {
+		return this.http.execute(POSTS_RESTORE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на пост. */
 	like(postId, options = {}) {
-		return this.http.operation("posts.like", {
+		return this.http.execute(POSTS_LIKE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с поста. */
 	unlike(postId, options = {}) {
-		return this.http.operation("posts.unlike", {
+		return this.http.execute(POSTS_UNLIKE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
@@ -2628,7 +3238,7 @@ var PostsResource = class extends BaseResource {
 	* для файлов здесь нет.
 	*/
 	repost(postId, content = "", options = {}) {
-		return this.http.operation("posts.repost", {
+		return this.http.execute(POSTS_REPOST, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
 			body: { content },
 			...options
@@ -2636,21 +3246,21 @@ var PostsResource = class extends BaseResource {
 	}
 	/** Отменяет репост. */
 	unrepost(postId, options = {}) {
-		return this.http.operation("posts.unrepost", {
+		return this.voidOperation(POSTS_UNREPOST, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
 			...options
 		});
 	}
 	/** Закрепляет пост в профиле. */
 	pin(postId, options = {}) {
-		return this.http.operation("posts.pin", {
+		return this.http.execute(POSTS_PIN, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
 			...options
 		});
 	}
 	/** Открепляет пост. */
 	unpin(postId, options = {}) {
-		return this.http.operation("posts.unpin", {
+		return this.http.execute(POSTS_UNPIN, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
 			...options
 		});
@@ -2661,20 +3271,19 @@ var PostsResource = class extends BaseResource {
 	* @param optionIds выбранные варианты; несколько допустимы только при `multipleChoice`
 	*/
 	vote(postId, optionIds, options = {}) {
-		return this.http.operation("posts.vote", {
+		return this.http.execute(POSTS_VOTE, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/poll/vote`,
 			body: { optionIds },
 			...options
 		});
 	}
 	/** Запрашивает счётчики сразу для нескольких постов. */
-	async stats(ids, options = {}) {
-		const body = await this.http.operation("posts.stats", {
+	stats(ids, options = {}) {
+		return this.http.execute(POSTS_STATS, {
 			path: "/api/posts/stats",
 			body: { ids },
 			...options
 		});
-		return pickArray(body, "posts");
 	}
 	/**
 	* Загружает страницу стены пользователя.
@@ -2744,7 +3353,7 @@ var PostsResource = class extends BaseResource {
 	async comment(postId, input, options = {}) {
 		const data = resolveComment(typeof input === "string" ? { content: input } : input);
 		const attachmentIds = await this.#collectAttachments(data, options);
-		return this.http.operation("posts.comment", {
+		return this.http.execute(POSTS_COMMENT, {
 			path: `/api/posts/${encodePathSegment(postId, "postId")}/comments`,
 			body: {
 				content: data.content ?? "",
@@ -2865,6 +3474,7 @@ function resolveReport(input) {
 }
 //#endregion
 //#region src/resources/reports.ts
+const REPORTS_CREATE = passthroughOperation("reports.create");
 /**
 * Жалобы на контент и пользователей.
 *
@@ -2885,7 +3495,7 @@ var ReportsResource = class extends BaseResource {
 	*/
 	create(input, options = {}) {
 		const data = resolveReport(input);
-		return this.http.operation("reports.create", {
+		return this.http.execute(REPORTS_CREATE, {
 			path: "/api/reports",
 			body: data,
 			...options
@@ -2894,6 +3504,10 @@ var ReportsResource = class extends BaseResource {
 };
 //#endregion
 //#region src/resources/search.ts
+const SEARCH_ALL = defineBuiltInOperation("search.all", (body) => ({
+	users: pickArray(body, "users"),
+	hashtags: pickArray(body, "hashtags")
+}));
 /**
 * Глобальный поиск.
 *
@@ -2908,20 +3522,23 @@ var SearchResource = class extends BaseResource {
 	* const { users, hashtags } = await itd.search.all('арт');
 	* ```
 	*/
-	async all(query, options = {}) {
-		const body = await this.http.operation("search.all", {
+	all(query, options = {}) {
+		return this.http.execute(SEARCH_ALL, {
 			path: "/api/search",
 			query: { q: query },
 			...options
 		});
-		return {
-			users: pickArray(body, "users"),
-			hashtags: pickArray(body, "hashtags")
-		};
 	}
 };
 //#endregion
 //#region src/resources/subscription.ts
+const SUBSCRIPTION_METHODS = defineBuiltInOperation("subscription.methods", (body) => Array.isArray(body) ? body : []);
+const SUBSCRIPTION_STATUS = passthroughOperation("subscription.status");
+const SUBSCRIPTION_PAY = passthroughOperation("subscription.pay");
+const SUBSCRIPTION_SET_AUTO_RENEWAL = passthroughOperation("subscription.setAutoRenewal");
+const SUBSCRIPTION_BIND_CARD = passthroughOperation("subscription.bindCard");
+const SUBSCRIPTION_SET_DEFAULT_METHOD = passthroughOperation("subscription.setDefaultMethod");
+const SUBSCRIPTION_REMOVE_METHOD = voidOperation("subscription.removeMethod");
 /**
 * Подписка и способы оплаты.
 *
@@ -2930,7 +3547,7 @@ var SearchResource = class extends BaseResource {
 var SubscriptionResource = class extends BaseResource {
 	/** Загружает состояние подписки и её цену. */
 	status(options = {}) {
-		return this.http.operation("subscription.status", {
+		return this.http.execute(SUBSCRIPTION_STATUS, {
 			path: "/api/v1/subscription/",
 			...options
 		});
@@ -2941,14 +3558,14 @@ var SubscriptionResource = class extends BaseResource {
 	* Форма ответа в документации API не описана, поэтому тип результата не уточняется.
 	*/
 	pay(options = {}) {
-		return this.http.operation("subscription.pay", {
+		return this.http.execute(SUBSCRIPTION_PAY, {
 			path: "/api/v1/subscription/pay",
 			...options
 		});
 	}
 	/** Включает или отключает автопродление. */
 	setAutoRenewal(enabled, options = {}) {
-		return this.http.operation("subscription.setAutoRenewal", {
+		return this.http.execute(SUBSCRIPTION_SET_AUTO_RENEWAL, {
 			path: "/api/v1/subscription/auto-renewal",
 			body: { enabled },
 			...options
@@ -2956,29 +3573,28 @@ var SubscriptionResource = class extends BaseResource {
 	}
 	/** Запускает привязку карты. */
 	bindCard(options = {}) {
-		return this.http.operation("subscription.bindCard", {
+		return this.http.execute(SUBSCRIPTION_BIND_CARD, {
 			path: "/api/v1/subscription/bind-card",
 			...options
 		});
 	}
 	/** Загружает список способов оплаты. Пустой массив, если карт нет. */
-	async methods(options = {}) {
-		const body = await this.http.operation("subscription.methods", {
+	methods(options = {}) {
+		return this.http.execute(SUBSCRIPTION_METHODS, {
 			path: "/api/v1/subscription/methods",
 			...options
 		});
-		return Array.isArray(body) ? body : [];
 	}
 	/** Делает способ оплаты основным. */
 	setDefaultMethod(methodId, options = {}) {
-		return this.http.operation("subscription.setDefaultMethod", {
+		return this.http.execute(SUBSCRIPTION_SET_DEFAULT_METHOD, {
 			path: `/api/v1/subscription/methods/${encodePathSegment(methodId, "methodId")}/default`,
 			...options
 		});
 	}
 	/** Удаляет способ оплаты. */
 	removeMethod(methodId, options = {}) {
-		return this.http.operation("subscription.removeMethod", {
+		return this.voidOperation(SUBSCRIPTION_REMOVE_METHOD, {
 			path: `/api/v1/subscription/methods/${encodePathSegment(methodId, "methodId")}`,
 			...options
 		});
@@ -3137,7 +3753,7 @@ var TelemetryBatchImpl = class {
 	close() {
 		return this.#close(false);
 	}
-	/** Внутренняя финализация после перехода клиента в terminal state. */
+	/** Внутренняя отправка данных после вызова `dispose()`. */
 	closeForDispose() {
 		this.prepareForDispose();
 		return this.#close(true);
@@ -3233,7 +3849,7 @@ var TelemetryResource = class extends BaseResource {
 			},
 			...requestOptions
 		};
-		return disposeCleanup ? this.http.cleanupOperation("telemetry.dwell", options) : this.http.operation("telemetry.dwell", options);
+		return disposeCleanup ? this.http.cleanupOperation(TELEMETRY_DWELL, options) : this.http.execute(TELEMETRY_DWELL, options);
 	}
 	/** Отправляет события взаимодействия с контентом (`POST /api/v1/x`). */
 	interaction(entries, telemetryOptions = {}, requestOptions = {}) {
@@ -3257,7 +3873,7 @@ var TelemetryResource = class extends BaseResource {
 			},
 			...requestOptions
 		};
-		return disposeCleanup ? this.http.cleanupOperation("telemetry.interaction", options) : this.http.operation("telemetry.interaction", options);
+		return disposeCleanup ? this.http.cleanupOperation(TELEMETRY_INTERACTION, options) : this.http.execute(TELEMETRY_INTERACTION, options);
 	}
 	/** Начинает измерять время просмотра и отправляет результат после `finish()`. */
 	startView(input, options = {}, requestOptions = {}) {
@@ -3300,12 +3916,43 @@ var TelemetryResource = class extends BaseResource {
 function prepareTelemetryForDispose(resource) {
 	if (resource) TELEMETRY_DISPOSE_PREPARERS.get(resource)?.();
 }
-/** Финализирует созданные накопители после перехода клиента в terminal state. @internal */
+/** Отправляет и закрывает созданные накопители после вызова `dispose()`. @internal */
 function closeTelemetryForDispose(resource) {
 	return resource ? TELEMETRY_DISPOSE_CLOSERS.get(resource)?.() ?? Promise.resolve() : Promise.resolve();
 }
+const TELEMETRY_DWELL = defineBuiltInOperation("telemetry.dwell");
+const TELEMETRY_INTERACTION = defineBuiltInOperation("telemetry.interaction");
 //#endregion
 //#region src/resources/users.ts
+const userListOperation = (id) => pageOperation(id, (body) => readPagedPage(body, "users", "followers", "following", "blocked"));
+const USER_LIST_OPERATIONS = {
+	"users.followers": userListOperation("users.followers"),
+	"users.following": userListOperation("users.following"),
+	"users.blocked": userListOperation("users.blocked")
+};
+const USERS_CHECK_USERNAME = defineBuiltInOperation("users.checkUsername", (body) => pickBoolean(body, "available"));
+const USERS_SEARCH = defineBuiltInOperation("users.search", (body) => pickArray(body, "users"));
+const USERS_WHO_TO_FOLLOW = defineBuiltInOperation("users.whoToFollow", (body) => pickArray(body, "users"));
+const USERS_TOP_CLANS = defineBuiltInOperation("users.topClans", (body) => pickArray(body, "clans"));
+const USERS_PINS = defineBuiltInOperation("users.pins", (body) => ({
+	pins: pickArray(body, "pins"),
+	activePin: pickString(body, "activePin") ?? null
+}));
+const USERS_ME = passthroughOperation("users.me");
+const USERS_UPDATE_ME = passthroughOperation("users.updateMe");
+const USERS_CREATE_PROFILE = passthroughOperation("users.createProfile");
+const USERS_GET = passthroughOperation("users.get");
+const USERS_FOLLOW = passthroughOperation("users.follow");
+const USERS_FOLLOW_STATUS = passthroughOperation("users.followStatus");
+const USERS_GET_PRIVACY = passthroughOperation("users.getPrivacy");
+const USERS_UPDATE_PRIVACY = passthroughOperation("users.updatePrivacy");
+const USERS_DEACTIVATE = voidOperation("users.deactivate");
+const USERS_RESTORE = voidOperation("users.restore");
+const USERS_UNFOLLOW = voidOperation("users.unfollow");
+const USERS_BLOCK = voidOperation("users.block");
+const USERS_UNBLOCK = voidOperation("users.unblock");
+const USERS_SET_PIN = voidOperation("users.setPin");
+const USERS_REMOVE_PIN = voidOperation("users.removePin");
 /**
 * Пользователи: профили, подписки, блокировки, приватность.
 *
@@ -3326,23 +3973,22 @@ var UsersResource = class extends BaseResource {
 	* сервер его сейчас не читает (см. {@link followers}): когда починят — заработает само.
 	*/
 	#userList = this.paginated({
-		operationId: (p) => p.operationId,
+		operation: (p) => p.operation,
 		path: (p) => p.path,
 		query: (p) => ({ limit: p.limit }),
 		start: (p) => p.page !== void 0 ? { page: p.page } : {},
-		read: (body) => readPagedPage(body, "users", "followers", "following", "blocked"),
 		mode: PaginationMode.Page
 	});
 	/** Загружает свой профиль — с подпиской и признаком подтверждённого телефона. */
 	me(options = {}) {
-		return this.http.operation("users.me", {
+		return this.http.execute(USERS_ME, {
 			path: "/api/users/me",
 			...options
 		});
 	}
 	/** Обновляет свой профиль. Передавайте только изменяемые поля. */
 	updateMe(input, options = {}) {
-		return this.http.operation("users.updateMe", {
+		return this.http.execute(USERS_UPDATE_ME, {
 			path: "/api/users/me",
 			body: input,
 			...options
@@ -3369,21 +4015,21 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Деактивирует аккаунт. Вернуть его можно через {@link restore}. */
 	deactivate(options = {}) {
-		return this.http.operation("users.deactivate", {
+		return this.voidOperation(USERS_DEACTIVATE, {
 			path: "/api/users/me",
 			...options
 		});
 	}
 	/** Восстанавливает деактивированный аккаунт. */
 	restore(options = {}) {
-		return this.http.operation("users.restore", {
+		return this.voidOperation(USERS_RESTORE, {
 			path: "/api/users/me/restore",
 			...options
 		});
 	}
 	/** Создаёт профиль после регистрации. */
 	createProfile(input, options = {}) {
-		return this.http.operation("users.createProfile", {
+		return this.http.execute(USERS_CREATE_PROFILE, {
 			path: "/api/users/profile",
 			body: input,
 			...options
@@ -3401,23 +4047,22 @@ var UsersResource = class extends BaseResource {
 	* ```
 	*/
 	get(user, options = {}) {
-		return this.http.operation("users.get", {
+		return this.http.execute(USERS_GET, {
 			path: `/api/users/${encodePathSegment(user, "user")}`,
 			...options
 		});
 	}
 	/** Проверяет, свободно ли имя пользователя. */
-	async checkUsername(username, options = {}) {
-		const body = await this.http.operation("users.checkUsername", {
+	checkUsername(username, options = {}) {
+		return this.http.execute(USERS_CHECK_USERNAME, {
 			path: "/api/users/check-username",
 			query: { username },
 			...options
 		});
-		return pickBoolean(body, "available");
 	}
 	/** Ищет пользователей по строке запроса. */
-	async search(query, params = {}, options = {}) {
-		const body = await this.http.operation("users.search", {
+	search(query, params = {}, options = {}) {
+		return this.http.execute(USERS_SEARCH, {
 			path: "/api/users/search",
 			query: {
 				q: query,
@@ -3425,23 +4070,20 @@ var UsersResource = class extends BaseResource {
 			},
 			...options
 		});
-		return pickArray(body, "users");
 	}
 	/** Загружает рекомендации, на кого подписаться. */
-	async whoToFollow(options = {}) {
-		const body = await this.http.operation("users.whoToFollow", {
+	whoToFollow(options = {}) {
+		return this.http.execute(USERS_WHO_TO_FOLLOW, {
 			path: "/api/users/suggestions/who-to-follow",
 			...options
 		});
-		return pickArray(body, "users");
 	}
 	/** Загружает рейтинг кланов. */
-	async topClans(options = {}) {
-		const body = await this.http.operation("users.topClans", {
+	topClans(options = {}) {
+		return this.http.execute(USERS_TOP_CLANS, {
 			path: "/api/users/stats/top-clans",
 			...options
 		});
-		return pickArray(body, "clans");
 	}
 	/**
 	* Подписывается на пользователя.
@@ -3449,7 +4091,7 @@ var UsersResource = class extends BaseResource {
 	* У закрытого профиля вместо подписки отправляется заявка — это видно по полю `status`.
 	*/
 	follow(user, options = {}) {
-		return this.http.operation("users.follow", {
+		return this.http.execute(USERS_FOLLOW, {
 			path: `/api/users/${encodePathSegment(user, "user")}/follow`,
 			body: {},
 			...options
@@ -3457,7 +4099,7 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Отписывается от пользователя. */
 	unfollow(user, options = {}) {
-		return this.http.operation("users.unfollow", {
+		return this.voidOperation(USERS_UNFOLLOW, {
 			path: `/api/users/${encodePathSegment(user, "user")}/follow`,
 			...options
 		});
@@ -3505,7 +4147,7 @@ var UsersResource = class extends BaseResource {
 	* ```
 	*/
 	followStatus(userIds, options = {}) {
-		return this.http.operation("users.followStatus", {
+		return this.http.execute(USERS_FOLLOW_STATUS, {
 			path: "/api/users/follow-status",
 			body: { userIds },
 			...options
@@ -3513,7 +4155,7 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Блокирует пользователя. */
 	block(user, options = {}) {
-		return this.http.operation("users.block", {
+		return this.voidOperation(USERS_BLOCK, {
 			path: `/api/users/${encodePathSegment(user, "user")}/block`,
 			body: {},
 			...options
@@ -3521,7 +4163,7 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Снимает блокировку. */
 	unblock(user, options = {}) {
-		return this.http.operation("users.unblock", {
+		return this.voidOperation(USERS_UNBLOCK, {
 			path: `/api/users/${encodePathSegment(user, "user")}/block`,
 			...options
 		});
@@ -3536,14 +4178,14 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Загружает настройки приватности. */
 	getPrivacy(options = {}) {
-		return this.http.operation("users.getPrivacy", {
+		return this.http.execute(USERS_GET_PRIVACY, {
 			path: "/api/users/me/privacy",
 			...options
 		});
 	}
 	/** Обновляет настройки приватности. Передавайте только изменяемые поля. */
 	updatePrivacy(input, options = {}) {
-		return this.http.operation("users.updatePrivacy", {
+		return this.http.execute(USERS_UPDATE_PRIVACY, {
 			path: "/api/users/me/privacy",
 			body: input,
 			...options
@@ -3554,19 +4196,15 @@ var UsersResource = class extends BaseResource {
 	*
 	* `activePin` — строка-идентификатор, а не объект.
 	*/
-	async pins(options = {}) {
-		const body = await this.http.operation("users.pins", {
+	pins(options = {}) {
+		return this.http.execute(USERS_PINS, {
 			path: "/api/users/me/pins",
 			...options
 		});
-		return {
-			pins: pickArray(body, "pins"),
-			activePin: pickString(body, "activePin") ?? null
-		};
 	}
 	/** Выбирает активный значок профиля. */
 	setPin(slug, options = {}) {
-		return this.http.operation("users.setPin", {
+		return this.voidOperation(USERS_SET_PIN, {
 			path: "/api/users/me/pin",
 			body: { slug },
 			...options
@@ -3574,7 +4212,7 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Снимает активный значок. */
 	removePin(options = {}) {
-		return this.http.operation("users.removePin", {
+		return this.voidOperation(USERS_REMOVE_PIN, {
 			path: "/api/users/me/pin",
 			...options
 		});
@@ -3582,20 +4220,22 @@ var UsersResource = class extends BaseResource {
 	#userPage(operationId, path, params, options) {
 		return this.#userList.list({
 			...params,
-			operationId,
+			operation: USER_LIST_OPERATIONS[operationId],
 			path
 		}, options);
 	}
 	#userPaginator(operationId, path, params, options) {
 		return this.#userList.iterate({
 			...params,
-			operationId,
+			operation: USER_LIST_OPERATIONS[operationId],
 			path
 		}, options);
 	}
 };
 //#endregion
 //#region src/resources/verification.ts
+const VERIFICATION_STATUS = passthroughOperation("verification.status");
+const VERIFICATION_SUBMIT = passthroughOperation("verification.submit");
 /**
 * Верификация профиля.
 *
@@ -3604,14 +4244,14 @@ var UsersResource = class extends BaseResource {
 var VerificationResource = class extends BaseResource {
 	/** Загружает статус заявки. Значение `none` означает, что заявка не подавалась. */
 	status(options = {}) {
-		return this.http.operation("verification.status", {
+		return this.http.execute(VERIFICATION_STATUS, {
 			path: "/api/verification/status",
 			...options
 		});
 	}
 	/** Подаёт заявку на верификацию с видео. */
 	submit(videoUrl, options = {}) {
-		return this.http.operation("verification.submit", {
+		return this.http.execute(VERIFICATION_SUBMIT, {
 			path: "/api/verification/submit",
 			body: { videoUrl },
 			...options
@@ -3656,11 +4296,11 @@ function createResources(deps) {
 			return comments;
 		},
 		get files() {
-			files ??= new FilesResource(deps.http, { fetch: deps.fetch });
+			files ??= new FilesResource(deps.http, { files: deps.files });
 			return files;
 		},
 		get notifications() {
-			notifications ??= new NotificationsResource(deps.http);
+			notifications ??= deps.createNotifications(deps.http);
 			return notifications;
 		},
 		get hashtags() {
@@ -3684,7 +4324,7 @@ function createResources(deps) {
 			return subscription;
 		},
 		get platform() {
-			platform ??= new PlatformResource(deps.http);
+			platform ??= new PlatformResource(deps.http, deps.status);
 			return platform;
 		},
 		get telemetry() {
@@ -3724,7 +4364,7 @@ function fromStream(factory, options = {}) {
 			throw new ItdFileError("не удалось открыть поток вложения", {
 				reason: ItdFileErrorReason.Read,
 				retryable: true,
-				cause: error
+				cause: redactErrorCause(error)
 			});
 		}
 		const content = isReadableByteStream(opened) ? { stream: opened } : opened;
@@ -3987,6 +4627,6 @@ function renderSpans(content, spans = [], options = {}) {
 	return result;
 }
 //#endregion
-export { BaseResource as C, mapPage as E, isBuilder as S, Paginator as T, ALLOWED_MIME_TYPES as _, fromStream as a, VIDEO_MIME_TYPES as b, report as c, autoSpans as d, markup as f, utcStampToIso as g, toDate as h, isMyProfile as i, post as l, parseMarkdown as m, renderSpans as n, fromUrl as o, parseHtml as p, statusDays as r, createResources as s, SpanRenderFormat as t, poll as u, AUDIO_MIME_TYPES as v, PaginationMode as w, comment as x, IMAGE_MIME_TYPES as y };
+export { ExtensibleOperationCatalog as A, utcStampToIso as C, Paginator as D, PaginationMode as E, mapPage as O, toDate as S, BaseResource as T, IMAGE_MIME_TYPES as _, fromStream as a, isBuilder as b, report as c, autoSpans as d, markup as f, AUDIO_MIME_TYPES as g, ALLOWED_MIME_TYPES as h, isMyProfile as i, createFeatureHost as k, post as l, parseMarkdown as m, renderSpans as n, fromUrl as o, parseHtml as p, statusDays as r, createResources as s, SpanRenderFormat as t, poll as u, VIDEO_MIME_TYPES as v, NotificationsResource as w, createStatusFeature as x, comment as y };
 
-//# sourceMappingURL=render-vtLixIiU.js.map
+//# sourceMappingURL=render-CiL1VS0b.js.map