itd-api 0.7.1 → 0.8.0

package/dist/shared/{render-DyeHJNBw.cjs → render-DNTESBSl.cjs}

@@ -1,7 +1,752 @@
-const require_url = require("./url-yjl2c8Ie.cjs");
-const require_errors = require("./errors-DfU8M5eS.cjs");
-const require_cookies = require("./cookies-DZwFq6kr.cjs");
-const require_options = require("./options-Dg5N3r1V.cjs");
+const require_url = require("./url-CFN1sT9S.cjs");
+const require_errors = require("./errors-BmP3TKoW.cjs");
+const require_redact = require("./redact-DB9EMGJx.cjs");
+const require_options = require("./options-BUfoHE9G.cjs");
+//#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 require_errors.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 require_errors.ItdConfigError(`feature «${owner}»: операция «${id}» должна находиться в пространстве имён «${owner}»`);
+		const occupiedBy = this.#operationOwners.get(id);
+		if (occupiedBy !== void 0) throw new require_errors.ItdConfigError(`feature «${owner}»: операция «${id}» уже зарегистрирована feature «${occupiedBy}»`);
+		if (this.#base.methodOf(id) !== void 0) throw new require_errors.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 require_options.fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new require_errors.ItdConfigError(`«${require_redact.redactUrl(target)}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_errors.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 = require_redact.redactUrl(requested.href);
+		throw new require_errors.ItdFileError(`не удалось получить файл по адресу ${safeUrl}`, {
+			reason: require_errors.ItdFileErrorReason.Network,
+			url: safeUrl,
+			retryable: true,
+			cause: require_redact.redactErrorCause(error)
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		const safeUrl = require_redact.redactUrl(finalUrl.href);
+		throw new require_errors.ItdFileError(`источник ${safeUrl} ответил статусом ${response.status}`, {
+			reason: require_errors.ItdFileErrorReason.Http,
+			url: safeUrl,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = require_options.resolveFileStreamOptions(options, require_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 require_options.fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = require_options.boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = require_options.resolveFileStreamOptions(options, require_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 = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) {
+		const safeUrl = require_redact.redactUrl(url.href);
+		throw new require_errors.ItdFileError(`источник ${safeUrl} не предоставил потоковое тело`, {
+			reason: require_errors.ItdFileErrorReason.StreamUnavailable,
+			url: safeUrl
+		});
+	}
+	const stream = require_options.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 require_options.FileTransferMode.Buffer;
+		if ("open" in input) return require_options.FileTransferMode.Stream;
+		if ("url" in input) return require_options.resolveFileStreamOptions(input).mode;
+		return require_options.FileTransferMode.Buffer;
+	}
+	async resolve(input, options = {}, context = {}) {
+		const attempt = context.attempt ?? 1;
+		if (!Number.isInteger(attempt) || attempt < 1) throw new require_errors.ItdConfigError(`attempt должен быть целым числом от 1, получено: ${attempt}`);
+		const maxBytes = require_options.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) === require_options.FileTransferMode.Stream ? await this.#openStream(input, options, fileContext, maxBytes) : await this.#loadBuffer(input, options, fileContext, maxBytes);
+			if (context.signal?.aborted) {
+				if (source.mode === require_options.FileTransferMode.Stream) await source.close();
+				throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			return source;
+		} catch (error) {
+			if (error instanceof require_errors.ItdError || context.signal?.aborted) throw error;
+			throw new require_errors.ItdFileError("не удалось получить содержимое вложения", {
+				reason: require_errors.ItdFileErrorReason.Read,
+				retryable: true,
+				cause: require_redact.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 require_errors.ItdConfigError("буферный источник должен вернуть объект с полем file");
+		if (!require_redact.isBlob(content.file) && !(content.file instanceof ArrayBuffer) && !ArrayBuffer.isView(content.file)) throw new require_errors.ItdConfigError("поле file должно содержать Blob, ArrayBuffer или Uint8Array");
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(require_redact.isBlob(content.file) ? content.file.type : void 0);
+		const blob = require_redact.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_options.fileTooLarge(void 0, maxBytes, blob.size);
+		return {
+			mode: require_options.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 || !require_options.isReadableByteStream(opened.stream)) {
+			await opened?.close?.();
+			throw new require_errors.ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
+		}
+		let handedOff = false;
+		const closeOpened = closeOnce(async () => {
+			await opened.close?.();
+		});
+		try {
+			require_options.optionalBytes(opened.size, "size");
+			if (maxBytes !== void 0 && opened.size !== void 0 && opened.size > maxBytes) throw require_options.fileTooLarge(void 0, maxBytes, opened.size);
+			if (options.requireKnownSize === true && opened.size === void 0) throw new require_errors.ItdConfigError("размер потокового вложения должен быть известен до чтения");
+			const limits = require_options.resolveFileStreamOptions({
+				mode: require_options.FileTransferMode.Stream,
+				...maxBytes !== void 0 ? { maxBytes } : {},
+				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
+			});
+			const stream = require_options.isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : require_options.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: require_options.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) || require_redact.isBlob(input)) return {
+			file: input,
+			...require_redact.isFile(input) ? { filename: input.name } : {}
+		};
+		if (typeof input !== "object" || input === null) throw new require_errors.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 require_errors.ItdConfigError("потоковый источник нельзя использовать как буферный");
+		throw new require_errors.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 require_errors.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 require_errors.ItdConfigError(`${kind} должен иметь непустое имя`);
+	return value.trim();
+}
+function requireFeatureName(value) {
+	const name = requireName(value, "Feature");
+	if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new require_errors.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 require_errors.ItdConfigError(`feature «${owner}»: бакет «${localName}» должен быть объектом`);
+	if (bucket.limit !== void 0 && (!Number.isFinite(bucket.limit) || bucket.limit <= 0)) throw new require_errors.ItdConfigError(`feature «${owner}»: limit бакета «${localName}» должен быть положительным числом`);
+	if (bucket.concurrency !== void 0 && (!Number.isInteger(bucket.concurrency) || bucket.concurrency < 1)) throw new require_errors.ItdConfigError(`feature «${owner}»: concurrency бакета «${localName}» должен быть целым числом от 1`);
+	if (bucket.rps !== void 0 && (!Number.isFinite(bucket.rps) || bucket.rps <= 0)) throw new require_errors.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 require_errors.ItdStateError("Реестр feature уже освобождён");
+		if (typeof feature !== "object" || feature === null) throw new require_errors.ItdConfigError("feature должен быть объектом");
+		const name = requireFeatureName(feature.name);
+		if (this.#features.has(name)) throw new require_errors.ItdConfigError(`feature «${name}» уже установлен`);
+		if (typeof feature.setup !== "function") throw new require_errors.ItdConfigError(`feature «${name}» должен предоставлять setup()`);
+		if (typeof feature.operations !== "object" || feature.operations === null || Array.isArray(feature.operations)) throw new require_errors.ItdConfigError(`feature «${name}» должен объявлять operations`);
+		if (feature.services !== void 0 && !Array.isArray(feature.services)) throw new require_errors.ItdConfigError(`feature «${name}»: services должен быть массивом`);
+		if (feature.buckets !== void 0 && (typeof feature.buckets !== "object" || feature.buckets === null || Array.isArray(feature.buckets))) throw new require_errors.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 require_errors.ItdConfigError(`feature «${name}»: сервис «${serviceName}» уже принадлежит feature «${owner}»`);
+				if (services.has(serviceName)) throw new require_errors.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(require_url.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 require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» должна быть объектом`);
+				if (![
+					"GET",
+					"POST",
+					"PUT",
+					"PATCH",
+					"DELETE"
+				].includes(definition.method)) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестный HTTP-метод`);
+				if (!Object.values(require_url.RetrySafety).includes(definition.retrySafety)) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестную retrySafety`);
+				if (definition.service !== void 0 && typeof definition.service !== "string") throw new require_errors.ItdConfigError(`feature «${name}»: service операции «${localName}» должен быть строкой`);
+				if (definition.bucket !== void 0 && typeof definition.bucket !== "string") throw new require_errors.ItdConfigError(`feature «${name}»: bucket операции «${localName}» должен быть строкой`);
+				if (definition.read !== void 0 && typeof definition.read !== "function") throw new require_errors.ItdConfigError(`feature «${name}»: read операции «${localName}» должна быть функцией`);
+				if (definition.annotations !== void 0 && (typeof definition.annotations !== "object" || definition.annotations === null || Array.isArray(definition.annotations))) throw new require_errors.ItdConfigError(`feature «${name}»: annotations операции «${localName}» должны быть объектом`);
+				if (definition.service !== void 0 && !services.has(definition.service)) throw new require_errors.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 require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный бакет «${definition.bucket}»`);
+				const operationId = `${name}.${localName}`;
+				const contract = require_url.defineOperation(operationId, {
+					method: definition.method,
+					retrySafety: definition.retrySafety,
+					bucket,
+					...definition.annotations === void 0 ? {} : { annotations: definition.annotations }
+				}, definition.read ?? require_url.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 require_errors.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 require_errors.ItdStateError(`feature «${name}» не активен`);
+						const resolved = operations.get(operation);
+						if (!resolved) throw new require_errors.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 require_errors.ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.services.resolveBaseUrl(serviceName);
+				},
+				connection: (serviceName) => {
+					if (!services.has(serviceName)) throw new require_errors.ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.connection(serviceName);
+				},
+				manage: (resource) => {
+					this.#deps.assertActive(`зарегистрировать ресурс feature «${name}»`);
+					if (controller.signal.aborted) throw new require_errors.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 require_errors.ItdStateError(`feature «${name}» не активен`);
+				}
+			});
+			const installation = feature.setup(context);
+			if (typeof installation !== "object" || installation === null || !("api" in installation)) throw new require_errors.ItdConfigError(`setup() feature «${name}» должен вернуть объект с полем api`);
+			if (installation.close !== void 0 && typeof installation.close !== "function") throw new require_errors.ItdConfigError(`feature «${name}»: close должен быть функцией`);
+			if (installation.dispose !== void 0 && typeof installation.dispose !== "function") throw new require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 = require_url.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 require_errors.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 = require_url.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 require_errors.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 require_url.defineBuiltInOperation(id, read);
+}
 /**
 * Перебор страниц списка.
 *
@@ -244,70 +993,308 @@ var BaseResource = class {
 	constructor(http) {
 		this.http = http;
 	}
-	/**
-	* Собирает перебор страниц.
-	*
-	* @param mode схема пагинации эндпоинта
-	* @param load загружает одну страницу для указанной позиции
-	* @param options только управление самим перебором: предел, отмена и начальная позиция
-	*/
-	paginate(mode, load, options) {
-		return new Paginator({
-			mode,
-			load,
-			...options?.maxPages !== void 0 ? { maxPages: options.maxPages } : {},
-			...options?.signal !== void 0 ? { signal: options.signal } : {},
-			...options?.start !== void 0 ? { start: options.start } : {}
+	/** Выполняет операцию без возвращаемого значения и отбрасывает служебное тело ответа. */
+	voidOperation(operation, options) {
+		return this.http.execute(operation, options);
+	}
+	/**
+	* Собирает перебор страниц.
+	*
+	* @param mode схема пагинации эндпоинта
+	* @param load загружает одну страницу для указанной позиции
+	* @param options только управление самим перебором: предел, отмена и начальная позиция
+	*/
+	paginate(mode, load, options) {
+		return new Paginator({
+			mode,
+			load,
+			...options?.maxPages !== void 0 ? { maxPages: options.maxPages } : {},
+			...options?.signal !== void 0 ? { signal: options.signal } : {},
+			...options?.start !== void 0 ? { start: options.start } : {}
+		});
+	}
+	/**
+	* Собирает пару «загрузка страницы + перебор» из одного описания.
+	*
+	* Путь, параметры запроса и разбор ответа задаются один раз; `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(require_url.normalizeNotification)
+	};
+});
+const NOTIFICATIONS_COUNT = require_url.defineBuiltInOperation("notifications.count", (body) => require_url.pickNumber(body, "count", 0));
+const markedCountOperation = (id) => require_url.defineBuiltInOperation(id, (body) => require_url.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 = require_url.defineBuiltInOperation("notifications.getSettings", readSettings);
+const NOTIFICATIONS_UPDATE_SETTINGS = require_url.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] = require_url.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/${require_redact.encodePathSegment(notificationId, "notificationId")}/read`,
+			...options
+		});
+	}
+	/**
+	* Отмечает прочитанными сразу несколько уведомлений.
+	*
+	* Список автоматически режется на части по 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);
+			marked += await this.http.execute(NOTIFICATIONS_MARK_READ_BATCH, {
+				path: "/api/notifications/read-batch",
+				body: { ids: chunk },
+				...options
+			});
+		}
+		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
 		});
 	}
 	/**
-	* Собирает пару «загрузка страницы + перебор» из одного описания.
-	*
-	* Путь, параметры запроса и разбор ответа задаются один раз; `list` и `iterate`
-	* строятся из них.
+	* Обновляет настройки уведомлений.
 	*
-	* @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,
-	* });
-	* ```
+	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
 	*/
-	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),
-				...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)
-				});
-			}
-		};
+	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 (!require_url.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: require_url.STATUS_SERVICE,
+			baseUrl: require_url.DEFAULT_STATUS_BASE_URL,
+			auth: false
+		}],
+		operations: { get: {
+			method: "GET",
+			retrySafety: require_url.RetrySafety.Safe,
+			service: require_url.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 = require_url.passthroughOperation("comments.reply");
+const COMMENTS_UPDATE = require_url.passthroughOperation("comments.update");
+const COMMENTS_RESTORE = require_url.passthroughOperation("comments.restore");
+const COMMENTS_LIKE = require_url.passthroughOperation("comments.like");
+const COMMENTS_UNLIKE = require_url.passthroughOperation("comments.unlike");
+const COMMENTS_REMOVE = require_url.voidOperation("comments.remove");
 /**
 * Комментарии и ответы на них.
 *
@@ -480,11 +1474,10 @@ var CommentsResource = class extends BaseResource {
 	#uploadFiles;
 	/** Ответы на комментарий: `/api/comments/{id}/replies`, постраничная пагинация. */
 	#replies = this.paginated({
-		operationId: "comments.replies",
-		path: (p) => `/api/comments/${require_cookies.encodePathSegment(p.commentId, "commentId")}/replies`,
+		operation: COMMENTS_REPLIES,
+		path: (p) => `/api/comments/${require_redact.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,8 +1516,8 @@ 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", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/replies`,
+		return this.http.execute(COMMENTS_REPLY, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/replies`,
 			body: {
 				content: data.content ?? "",
 				attachmentIds,
@@ -535,176 +1528,42 @@ var CommentsResource = class extends BaseResource {
 	}
 	/** Редактирует текст комментария. */
 	update(commentId, content, options = {}) {
-		return this.http.operation("comments.update", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}`,
+		return this.http.execute(COMMENTS_UPDATE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}`,
 			body: { content },
 			...options
 		});
 	}
 	/** Удаляет комментарий. Восстановить его можно через {@link restore}. */
 	remove(commentId, options = {}) {
-		return this.http.operation("comments.remove", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}`,
+		return this.voidOperation(COMMENTS_REMOVE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый комментарий. */
 	restore(commentId, options = {}) {
-		return this.http.operation("comments.restore", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/restore`,
+		return this.http.execute(COMMENTS_RESTORE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на комментарий. */
 	like(commentId, options = {}) {
-		return this.http.operation("comments.like", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/like`,
+		return this.http.execute(COMMENTS_LIKE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с комментария. */
 	unlike(commentId, options = {}) {
-		return this.http.operation("comments.unlike", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/like`,
+		return this.http.execute(COMMENTS_UNLIKE, {
+			path: `/api/comments/${require_redact.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 require_options.fileTooLarge(url, maxBytes, size);
-	return size;
-}
-/** Получает HTTP-ответ источника и проверяет его статус. */
-async function fetchFile(target, options, context) {
-	let requested;
-	try {
-		requested = new URL(target);
-	} catch {
-		throw new require_errors.ItdConfigError(`«${target}» не разбирается как адрес`);
-	}
-	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_errors.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
-	let response;
-	try {
-		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
-	} catch (error) {
-		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
-		throw new require_errors.ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
-			reason: require_errors.ItdFileErrorReason.Network,
-			url: requested.href,
-			retryable: true,
-			cause: error
-		});
-	}
-	const finalUrl = response.url ? new URL(response.url) : requested;
-	if (!response.ok) {
-		await response.body?.cancel().catch(() => {});
-		throw new require_errors.ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
-			reason: require_errors.ItdFileErrorReason.Http,
-			url: finalUrl.href,
-			status: response.status,
-			retryable: response.status === 408 || response.status === 429 || response.status >= 500
-		});
-	}
-	const { maxBytes } = require_options.resolveFileStreamOptions(options, require_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 require_options.fileTooLarge(url, maxBytes, blob.size);
-		return blob;
-	}
-	const chunks = [];
-	const reader = require_options.boundedFileStream(response.body, {
-		...maxBytes !== void 0 ? { maxBytes } : {},
-		streamBufferBytes,
-		...signal ? { signal } : {},
-		url,
-		retryableRead: true
-	}).getReader();
-	try {
-		for (;;) {
-			const next = await reader.read();
-			if (next.done) break;
-			chunks.push(next.value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
-}
-/** Скачивает файл целиком с ограничением размера. @internal */
-async function downloadFile(target, options, context) {
-	const resolved = require_options.resolveFileStreamOptions(options, require_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 = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
-	const { response, url, size } = await fetchFile(target, options, context);
-	if (!response.body) throw new require_errors.ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
-		reason: require_errors.ItdFileErrorReason.StreamUnavailable,
-		url: url.href
-	});
-	const stream = require_options.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();
 /** Убирает возможность внедрить дополнительный multipart-заголовок через имя файла. */
@@ -841,12 +1700,17 @@ function assertAllowedMime(mimeType, filename) {
 	if (!mimeType) throw new require_errors.ItdConfigError(`Не удалось определить тип файла${filename ? ` «${filename}»` : ""}. Укажите его явно: { file, filename, contentType }.`);
 	if (!isAllowedMime(mimeType)) throw new require_errors.ItdConfigError(`Тип «${mimeType}» не поддерживается загрузкой. Допустимые: ${ALLOWED_MIME_TYPES.join(", ")}.`);
 }
+//#endregion
+//#region src/resources/files.ts
+const FILES_UPLOAD = require_url.passthroughOperation("files.upload");
+const FILES_GET = require_url.passthroughOperation("files.get");
+const FILES_REMOVE = require_url.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,15 +1739,15 @@ var FilesResource = class extends BaseResource {
 	* Для ещё не прикреплённого файла сервер может ответить `404`.
 	*/
 	get(fileId, options = {}) {
-		return this.http.operation("files.get", {
-			path: `/api/files/${require_cookies.encodePathSegment(fileId, "fileId")}`,
+		return this.http.execute(FILES_GET, {
+			path: `/api/files/${require_redact.encodePathSegment(fileId, "fileId")}`,
 			...options
 		});
 	}
 	/** Удаляет загруженный файл. */
 	remove(fileId, options = {}) {
-		return this.http.operation("files.remove", {
-			path: `/api/files/${require_cookies.encodePathSegment(fileId, "fileId")}`,
+		return this.voidOperation(FILES_REMOVE, {
+			path: `/api/files/${require_redact.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) === require_options.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 require_errors.ItdError || signal.aborted) throw error;
-				throw new require_errors.ItdFileError("не удалось получить содержимое вложения", {
-					reason: require_errors.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 === require_options.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 require_options.resolveFileStreamOptions(input).mode === require_options.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(require_url.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
-		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
-		const blob = require_url.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
-		const limits = require_options.resolveFileStreamOptions(options);
-		if (limits.maxBytes !== void 0 && blob.size > limits.maxBytes) throw new require_errors.ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${blob.size}`, {
-			reason: require_errors.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 require_errors.ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
-		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
-			await opened?.close?.();
-			throw new require_errors.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 = require_options.resolveFileStreamOptions({
-				mode: require_options.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 require_errors.ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${opened.size}`, {
-				reason: require_errors.ItdFileErrorReason.TooLarge,
-				limit: limits.maxBytes,
-				actual: opened.size
-			});
-			return {
-				mode: "stream",
-				stream: require_options.isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : require_options.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) || require_url.isBlob(input)) return {
-			file: input,
-			...require_url.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 require_errors.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 require_errors.ItdConfigError("потоковый источник нельзя использовать как буферный");
-		throw new require_errors.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 = require_url.defineBuiltInOperation("hashtags.search", (body) => require_url.pickArray(body, "hashtags"));
+const HASHTAGS_TRENDING = require_url.defineBuiltInOperation("hashtags.trending", (body) => require_url.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",
-		path: (p) => `/api/hashtags/${require_cookies.encodePathSegment(p.tag, "tag")}/posts`,
+		operation: HASHTAG_POSTS,
+		path: (p) => `/api/hashtags/${require_redact.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 require_url.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 require_url.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] = require_url.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(require_url.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 require_url.pickNumber(body, "count", 0);
-	}
-	/**
-	* Отмечает уведомление прочитанным.
-	*
-	* @returns сколько записей отметил сервер
-	*/
-	async markRead(notificationId, options = {}) {
-		const body = await this.http.operation("notifications.markRead", {
-			path: `/api/notifications/${require_cookies.encodePathSegment(notificationId, "notificationId")}/read`,
-			...options
-		});
-		return require_url.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 += require_url.pickNumber(body, "markedCount", 0);
-		}
-		return marked;
-	}
-	/** Отмечает прочитанными все уведомления. */
-	async markAllRead(options = {}) {
-		const body = await this.http.operation("notifications.markAllRead", {
-			path: "/api/notifications/read-all",
-			...options
-		});
-		return require_url.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 (!require_url.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 = require_url.defineBuiltInOperation("platform.changelog", (body) => Array.isArray(body) ? body : []);
+const PLATFORM_ANNOUNCEMENTS = require_url.defineBuiltInOperation("platform.announcements", (body) => require_url.pickArray(body, "announcements"));
+const PLATFORM_VERSION = require_url.passthroughOperation("platform.version");
+const PLATFORM_PORTAL = require_url.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 require_url.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: require_url.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: require_url.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 = require_url.defineBuiltInOperation("posts.stats", (body) => require_url.pickArray(body, "posts"));
+const POSTS_CREATE = require_url.passthroughOperation("posts.create");
+const POSTS_GET = require_url.passthroughOperation("posts.get");
+const POSTS_UPDATE = require_url.passthroughOperation("posts.update");
+const POSTS_RESTORE = require_url.passthroughOperation("posts.restore");
+const POSTS_LIKE = require_url.passthroughOperation("posts.like");
+const POSTS_UNLIKE = require_url.passthroughOperation("posts.unlike");
+const POSTS_REPOST = require_url.passthroughOperation("posts.repost");
+const POSTS_PIN = require_url.passthroughOperation("posts.pin");
+const POSTS_UNPIN = require_url.passthroughOperation("posts.unpin");
+const POSTS_VOTE = require_url.passthroughOperation("posts.vote");
+const POSTS_COMMENT = require_url.passthroughOperation("posts.comment");
+const POSTS_REMOVE = require_url.voidOperation("posts.remove");
+const POSTS_UNREPOST = require_url.voidOperation("posts.unrepost");
 /** Курсорная позиция из параметров: если курсор задан — с него, иначе с начала. */
 function cursorStart(params) {
 	return params.cursor ? { cursor: params.cursor } : {};
@@ -2464,48 +3078,44 @@ 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",
-		path: (p) => `/api/posts/user/${require_cookies.encodePathSegment(p.user, "user")}`,
+		operation: POSTS_BY_USER,
+		path: (p) => `/api/posts/user/${require_redact.encodePathSegment(p.user, "user")}`,
 		query: (p) => ({
 			limit: p.limit,
 			sort: p.sort,
 			pinnedPostId: p.pinnedPostId
 		}),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Понравившиеся посты пользователя: `/api/posts/user/{user}/liked`. */
 	#liked = this.paginated({
-		operationId: "posts.likedByUser",
-		path: (p) => `/api/posts/user/${require_cookies.encodePathSegment(p.user, "user")}/liked`,
+		operation: POSTS_LIKED_BY_USER,
+		path: (p) => `/api/posts/user/${require_redact.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",
-		path: (p) => `/api/posts/${require_cookies.encodePathSegment(p.postId, "postId")}/comments`,
+		operation: POSTS_COMMENTS,
+		path: (p) => `/api/posts/${require_redact.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,8 +3180,8 @@ var PostsResource = class extends BaseResource {
 	* В отличие от списков, здесь у поста заполнено поле `comments`.
 	*/
 	get(postId, options = {}) {
-		return this.http.operation("posts.get", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.http.execute(POSTS_GET, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			...options
 		});
 	}
@@ -2584,8 +3194,8 @@ var PostsResource = class extends BaseResource {
 	*/
 	update(postId, input, options = {}) {
 		const data = resolvePostUpdate(input);
-		return this.http.operation("posts.update", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.http.execute(POSTS_UPDATE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			body: {
 				content: data.content,
 				...data.spans ? { spans: data.spans } : {}
@@ -2595,29 +3205,29 @@ var PostsResource = class extends BaseResource {
 	}
 	/** Удаляет пост. Восстановить его можно через {@link restore}. */
 	remove(postId, options = {}) {
-		return this.http.operation("posts.remove", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.voidOperation(POSTS_REMOVE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый пост. */
 	restore(postId, options = {}) {
-		return this.http.operation("posts.restore", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/restore`,
+		return this.http.execute(POSTS_RESTORE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на пост. */
 	like(postId, options = {}) {
-		return this.http.operation("posts.like", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/like`,
+		return this.http.execute(POSTS_LIKE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с поста. */
 	unlike(postId, options = {}) {
-		return this.http.operation("posts.unlike", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/like`,
+		return this.http.execute(POSTS_UNLIKE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
 	}
@@ -2628,30 +3238,30 @@ var PostsResource = class extends BaseResource {
 	* для файлов здесь нет.
 	*/
 	repost(postId, content = "", options = {}) {
-		return this.http.operation("posts.repost", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/repost`,
+		return this.http.execute(POSTS_REPOST, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/repost`,
 			body: { content },
 			...options
 		});
 	}
 	/** Отменяет репост. */
 	unrepost(postId, options = {}) {
-		return this.http.operation("posts.unrepost", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/repost`,
+		return this.voidOperation(POSTS_UNREPOST, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/repost`,
 			...options
 		});
 	}
 	/** Закрепляет пост в профиле. */
 	pin(postId, options = {}) {
-		return this.http.operation("posts.pin", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/pin`,
+		return this.http.execute(POSTS_PIN, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/pin`,
 			...options
 		});
 	}
 	/** Открепляет пост. */
 	unpin(postId, options = {}) {
-		return this.http.operation("posts.unpin", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/pin`,
+		return this.http.execute(POSTS_UNPIN, {
+			path: `/api/posts/${require_redact.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", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/poll/vote`,
+		return this.http.execute(POSTS_VOTE, {
+			path: `/api/posts/${require_redact.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 require_url.pickArray(body, "posts");
 	}
 	/**
 	* Загружает страницу стены пользователя.
@@ -2744,8 +3353,8 @@ 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", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/comments`,
+		return this.http.execute(POSTS_COMMENT, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/comments`,
 			body: {
 				content: data.content ?? "",
 				attachmentIds
@@ -2865,6 +3474,7 @@ function resolveReport(input) {
 }
 //#endregion
 //#region src/resources/reports.ts
+const REPORTS_CREATE = require_url.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 = require_url.defineBuiltInOperation("search.all", (body) => ({
+	users: require_url.pickArray(body, "users"),
+	hashtags: require_url.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: require_url.pickArray(body, "users"),
-			hashtags: require_url.pickArray(body, "hashtags")
-		};
 	}
 };
 //#endregion
 //#region src/resources/subscription.ts
+const SUBSCRIPTION_METHODS = require_url.defineBuiltInOperation("subscription.methods", (body) => Array.isArray(body) ? body : []);
+const SUBSCRIPTION_STATUS = require_url.passthroughOperation("subscription.status");
+const SUBSCRIPTION_PAY = require_url.passthroughOperation("subscription.pay");
+const SUBSCRIPTION_SET_AUTO_RENEWAL = require_url.passthroughOperation("subscription.setAutoRenewal");
+const SUBSCRIPTION_BIND_CARD = require_url.passthroughOperation("subscription.bindCard");
+const SUBSCRIPTION_SET_DEFAULT_METHOD = require_url.passthroughOperation("subscription.setDefaultMethod");
+const SUBSCRIPTION_REMOVE_METHOD = require_url.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,30 +3573,29 @@ 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", {
-			path: `/api/v1/subscription/methods/${require_cookies.encodePathSegment(methodId, "methodId")}/default`,
+		return this.http.execute(SUBSCRIPTION_SET_DEFAULT_METHOD, {
+			path: `/api/v1/subscription/methods/${require_redact.encodePathSegment(methodId, "methodId")}/default`,
 			...options
 		});
 	}
 	/** Удаляет способ оплаты. */
 	removeMethod(methodId, options = {}) {
-		return this.http.operation("subscription.removeMethod", {
-			path: `/api/v1/subscription/methods/${require_cookies.encodePathSegment(methodId, "methodId")}`,
+		return this.voidOperation(SUBSCRIPTION_REMOVE_METHOD, {
+			path: `/api/v1/subscription/methods/${require_redact.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);
@@ -3207,7 +3823,7 @@ var TelemetryResource = class extends BaseResource {
 	}
 	/** Идентификатор сессии телеметрии, общий для всех событий этого ресурса. */
 	get sessionId() {
-		this.#sessionId ??= require_url.createDeviceId();
+		this.#sessionId ??= require_redact.createDeviceId();
 		return this.#sessionId;
 	}
 	/** Отправляет события просмотра постов (`POST /api/v1/i`). */
@@ -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 = require_url.defineBuiltInOperation("telemetry.dwell");
+const TELEMETRY_INTERACTION = require_url.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 = require_url.defineBuiltInOperation("users.checkUsername", (body) => require_url.pickBoolean(body, "available"));
+const USERS_SEARCH = require_url.defineBuiltInOperation("users.search", (body) => require_url.pickArray(body, "users"));
+const USERS_WHO_TO_FOLLOW = require_url.defineBuiltInOperation("users.whoToFollow", (body) => require_url.pickArray(body, "users"));
+const USERS_TOP_CLANS = require_url.defineBuiltInOperation("users.topClans", (body) => require_url.pickArray(body, "clans"));
+const USERS_PINS = require_url.defineBuiltInOperation("users.pins", (body) => ({
+	pins: require_url.pickArray(body, "pins"),
+	activePin: require_url.pickString(body, "activePin") ?? null
+}));
+const USERS_ME = require_url.passthroughOperation("users.me");
+const USERS_UPDATE_ME = require_url.passthroughOperation("users.updateMe");
+const USERS_CREATE_PROFILE = require_url.passthroughOperation("users.createProfile");
+const USERS_GET = require_url.passthroughOperation("users.get");
+const USERS_FOLLOW = require_url.passthroughOperation("users.follow");
+const USERS_FOLLOW_STATUS = require_url.passthroughOperation("users.followStatus");
+const USERS_GET_PRIVACY = require_url.passthroughOperation("users.getPrivacy");
+const USERS_UPDATE_PRIVACY = require_url.passthroughOperation("users.updatePrivacy");
+const USERS_DEACTIVATE = require_url.voidOperation("users.deactivate");
+const USERS_RESTORE = require_url.voidOperation("users.restore");
+const USERS_UNFOLLOW = require_url.voidOperation("users.unfollow");
+const USERS_BLOCK = require_url.voidOperation("users.block");
+const USERS_UNBLOCK = require_url.voidOperation("users.unblock");
+const USERS_SET_PIN = require_url.voidOperation("users.setPin");
+const USERS_REMOVE_PIN = require_url.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", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}`,
+		return this.http.execute(USERS_GET, {
+			path: `/api/users/${require_redact.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 require_url.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 require_url.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 require_url.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 require_url.pickArray(body, "clans");
 	}
 	/**
 	* Подписывается на пользователя.
@@ -3449,16 +4091,16 @@ var UsersResource = class extends BaseResource {
 	* У закрытого профиля вместо подписки отправляется заявка — это видно по полю `status`.
 	*/
 	follow(user, options = {}) {
-		return this.http.operation("users.follow", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/follow`,
+		return this.http.execute(USERS_FOLLOW, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/follow`,
 			body: {},
 			...options
 		});
 	}
 	/** Отписывается от пользователя. */
 	unfollow(user, options = {}) {
-		return this.http.operation("users.unfollow", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/follow`,
+		return this.voidOperation(USERS_UNFOLLOW, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/follow`,
 			...options
 		});
 	}
@@ -3474,7 +4116,7 @@ var UsersResource = class extends BaseResource {
 	* на проверенных аккаунтах занижено примерно на 1–4%.
 	*/
 	followers(user, params = {}, options = {}) {
-		return this.#userPage("users.followers", `/api/users/${require_cookies.encodePathSegment(user, "user")}/followers`, params, options);
+		return this.#userPage("users.followers", `/api/users/${require_redact.encodePathSegment(user, "user")}/followers`, params, options);
 	}
 	/**
 	* Перебирает подписчиков.
@@ -3483,15 +4125,15 @@ var UsersResource = class extends BaseResource {
 	* см. {@link followers}. Метод оставлен на случай, если пагинацию починят.
 	*/
 	iterateFollowers(user, params = {}, options = {}) {
-		return this.#userPaginator("users.followers", `/api/users/${require_cookies.encodePathSegment(user, "user")}/followers`, params, options);
+		return this.#userPaginator("users.followers", `/api/users/${require_redact.encodePathSegment(user, "user")}/followers`, params, options);
 	}
 	/** Загружает подписки пользователя. Ограничения те же, что у {@link followers}. */
 	following(user, params = {}, options = {}) {
-		return this.#userPage("users.following", `/api/users/${require_cookies.encodePathSegment(user, "user")}/following`, params, options);
+		return this.#userPage("users.following", `/api/users/${require_redact.encodePathSegment(user, "user")}/following`, params, options);
 	}
 	/** Перебирает подписки. Закончится после первых 20 записей — см. {@link followers}. */
 	iterateFollowing(user, params = {}, options = {}) {
-		return this.#userPaginator("users.following", `/api/users/${require_cookies.encodePathSegment(user, "user")}/following`, params, options);
+		return this.#userPaginator("users.following", `/api/users/${require_redact.encodePathSegment(user, "user")}/following`, params, 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,16 +4155,16 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Блокирует пользователя. */
 	block(user, options = {}) {
-		return this.http.operation("users.block", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/block`,
+		return this.voidOperation(USERS_BLOCK, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/block`,
 			body: {},
 			...options
 		});
 	}
 	/** Снимает блокировку. */
 	unblock(user, options = {}) {
-		return this.http.operation("users.unblock", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/block`,
+		return this.voidOperation(USERS_UNBLOCK, {
+			path: `/api/users/${require_redact.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: require_url.pickArray(body, "pins"),
-			activePin: require_url.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 = require_url.passthroughOperation("verification.status");
+const VERIFICATION_SUBMIT = require_url.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 require_errors.ItdFileError("не удалось открыть поток вложения", {
 				reason: require_errors.ItdFileErrorReason.Read,
 				retryable: true,
-				cause: error
+				cause: require_redact.redactErrorCause(error)
 			});
 		}
 		const content = require_options.isReadableByteStream(opened) ? { stream: opened } : opened;
@@ -4005,12 +4645,24 @@ Object.defineProperty(exports, "BaseResource", {
 		return BaseResource;
 	}
 });
+Object.defineProperty(exports, "ExtensibleOperationCatalog", {
+	enumerable: true,
+	get: function() {
+		return ExtensibleOperationCatalog;
+	}
+});
 Object.defineProperty(exports, "IMAGE_MIME_TYPES", {
 	enumerable: true,
 	get: function() {
 		return IMAGE_MIME_TYPES;
 	}
 });
+Object.defineProperty(exports, "NotificationsResource", {
+	enumerable: true,
+	get: function() {
+		return NotificationsResource;
+	}
+});
 Object.defineProperty(exports, "PaginationMode", {
 	enumerable: true,
 	get: function() {
@@ -4047,12 +4699,24 @@ Object.defineProperty(exports, "comment", {
 		return comment;
 	}
 });
+Object.defineProperty(exports, "createFeatureHost", {
+	enumerable: true,
+	get: function() {
+		return createFeatureHost;
+	}
+});
 Object.defineProperty(exports, "createResources", {
 	enumerable: true,
 	get: function() {
 		return createResources;
 	}
 });
+Object.defineProperty(exports, "createStatusFeature", {
+	enumerable: true,
+	get: function() {
+		return createStatusFeature;
+	}
+});
 Object.defineProperty(exports, "fromStream", {
 	enumerable: true,
 	get: function() {
@@ -4144,4 +4808,4 @@ Object.defineProperty(exports, "utcStampToIso", {
 	}
 });
 
-//# sourceMappingURL=render-DyeHJNBw.cjs.map
+//# sourceMappingURL=render-DNTESBSl.cjs.map