itd-api 0.7.0 → 0.7.2

package/dist/shared/render-C6HRPs10.js

@@ -0,0 +1,4289 @@
+import { F as pickArray, H as RetrySafety, I as pickBoolean, J as DEFAULT_STATUS_BASE_URL, L as pickNumber, P as isRecord, R as pickObject, U as mergeService, Y as STATUS_SERVICE, it as isFile, nt as createDeviceId, p as InteractionType, r as normalizeNotification, rt as isBlob, v as ReportReason, x as SpanType, y as ReportTargetType, z as pickString } from "./url-IU0xN9wX.js";
+import { _ as ItdStateError, a as ItdConfigError, l as ItdFileError, s as ItdError, t as ItdAbortError, u as ItdFileErrorReason } from "./errors-Bhrd2fJd.js";
+import { o as encodePathSegment } from "./cookies-tX2sNwxb.js";
+import { a as fileTooLarge, c as FileTransferMode, i as isReadableByteStream, n as boundedFileStream, o as optionalBytes, r as isBoundedFileStream, s as DEFAULT_URL_FILE_MAX_BYTES, t as resolveFileStreamOptions } from "./options-DtATYdLr.js";
+//#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;
+	}
+	retrySafetyOf(id) {
+		return this.#operations.get(id)?.retrySafety ?? this.#base.retrySafetyOf(id);
+	}
+	methodOf(id) {
+		return this.#operations.get(id)?.method ?? this.#base.methodOf(id);
+	}
+	bucketOf(id) {
+		return this.#operations.get(id)?.bucket ?? this.#base.bucketOf(id);
+	}
+	isKnownBucket(name) {
+		return this.#bucketOwners.has(name) || this.#base.isKnownBucket(name);
+	}
+	/** Регистрирует принадлежащий feature бакет и возвращает откат регистрации. */
+	registerBucket(owner, name, definition) {
+		if (this.#base.isKnownBucket(name) || this.#bucketOwners.has(name)) throw new ItdConfigError(`feature «${owner}»: бакет «${name}» уже зарегистрирован`);
+		this.#bucketOwners.set(name, owner);
+		if (definition.limit !== void 0) this.#bucketLimits[name] = definition.limit;
+		if (definition.concurrency !== void 0) this.#bucketOverrides[name] = Object.freeze({ concurrency: definition.concurrency });
+		return () => {
+			if (this.#bucketOwners.get(name) !== owner) return;
+			this.#bucketOwners.delete(name);
+			delete this.#bucketLimits[name];
+			delete this.#bucketOverrides[name];
+		};
+	}
+	/** Регистрирует операцию и возвращает откат регистрации. */
+	registerOperation(owner, id, definition) {
+		const ownerPrefix = `${owner}.`;
+		if (!id.startsWith(ownerPrefix) || id.length === ownerPrefix.length) throw new ItdConfigError(`feature «${owner}»: операция «${id}» должна находиться в пространстве имён «${owner}»`);
+		const occupiedBy = this.#operationOwners.get(id);
+		if (occupiedBy !== void 0) throw new ItdConfigError(`feature «${owner}»: операция «${id}» уже зарегистрирована feature «${occupiedBy}»`);
+		if (this.#base.methodOf(id) !== void 0) throw new ItdConfigError(`feature «${owner}»: операция «${id}» уже существует в базовом каталоге`);
+		this.#operationOwners.set(id, owner);
+		this.#operations.set(id, Object.freeze({ ...definition }));
+		return () => {
+			if (this.#operationOwners.get(id) !== owner) return;
+			this.#operationOwners.delete(id);
+			this.#operations.delete(id);
+		};
+	}
+};
+//#endregion
+//#region src/core/features.ts
+function requireName(value, kind) {
+	if (typeof value !== "string" || value.trim() === "") throw new ItdConfigError(`${kind} должен иметь непустое имя`);
+	return value.trim();
+}
+function requireOperationName(value, featureName) {
+	const name = requireName(value, `Операция feature «${featureName}»`);
+	if (name.includes(".")) throw new ItdConfigError(`feature «${featureName}»: локальное имя операции «${name}» не должно содержать точку`);
+	return name;
+}
+function validateBucket(owner, localName, bucket) {
+	if (typeof bucket !== "object" || bucket === null || Array.isArray(bucket)) throw new ItdConfigError(`feature «${owner}»: бакет «${localName}» должен быть объектом`);
+	if (bucket.limit !== void 0 && (!Number.isFinite(bucket.limit) || bucket.limit <= 0)) throw new ItdConfigError(`feature «${owner}»: limit бакета «${localName}» должен быть положительным числом`);
+	if (bucket.concurrency !== void 0 && (!Number.isInteger(bucket.concurrency) || bucket.concurrency < 1)) throw new ItdConfigError(`feature «${owner}»: concurrency бакета «${localName}» должен быть целым числом от 1`);
+}
+/** Реестр feature одного facade. @internal */
+var FeatureRegistry = class {
+	#deps;
+	#features = /* @__PURE__ */ new Map();
+	#serviceOwners = /* @__PURE__ */ new Map();
+	#disposed = false;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	install(feature) {
+		this.#deps.assertActive("установить feature");
+		if (this.#disposed) throw new ItdStateError("Реестр feature уже освобождён");
+		if (typeof feature !== "object" || feature === null) throw new ItdConfigError("feature должен быть объектом");
+		const name = requireName(feature.name, "Feature");
+		if (this.#features.has(name)) throw new ItdConfigError(`feature «${name}» уже установлен`);
+		if (typeof feature.setup !== "function") throw new ItdConfigError(`feature «${name}» должен предоставлять setup()`);
+		if (typeof feature.operations !== "object" || feature.operations === null || Array.isArray(feature.operations)) throw new ItdConfigError(`feature «${name}» должен объявлять operations`);
+		if (feature.services !== void 0 && !Array.isArray(feature.services)) throw new ItdConfigError(`feature «${name}»: services должен быть массивом`);
+		if (feature.buckets !== void 0 && (typeof feature.buckets !== "object" || feature.buckets === null || Array.isArray(feature.buckets))) throw new ItdConfigError(`feature «${name}»: buckets должен быть объектом`);
+		const rollback = [];
+		const services = /* @__PURE__ */ new Set();
+		const bucketNames = /* @__PURE__ */ new Map();
+		const operations = /* @__PURE__ */ new Map();
+		const controller = new AbortController();
+		let committed = false;
+		try {
+			for (const service of feature.services ?? []) {
+				const serviceName = requireName(service?.name, `Сервис feature «${name}»`);
+				const owner = this.#serviceOwners.get(serviceName);
+				if (owner !== void 0) throw new ItdConfigError(`feature «${name}»: сервис «${serviceName}» уже принадлежит feature «${owner}»`);
+				if (services.has(serviceName)) throw new ItdConfigError(`feature «${name}»: сервис «${serviceName}» объявлен повторно`);
+				if (!this.#deps.services.has(serviceName)) {
+					this.#deps.services.define(service);
+					rollback.push(() => void this.#deps.services.delete(serviceName));
+				} else {
+					const override = this.#deps.serviceOverrides.find((candidate) => candidate.name.trim() === serviceName);
+					if (override) {
+						const previous = this.#deps.services.replace(mergeService(service, override));
+						rollback.push(() => void this.#deps.services.replace(previous));
+					}
+				}
+				this.#serviceOwners.set(serviceName, name);
+				rollback.push(() => {
+					if (this.#serviceOwners.get(serviceName) === name) this.#serviceOwners.delete(serviceName);
+				});
+				services.add(serviceName);
+			}
+			for (const [rawLocalName, bucket] of Object.entries(feature.buckets ?? {})) {
+				const localName = requireName(rawLocalName, `Бакет feature «${name}»`);
+				validateBucket(name, localName, bucket);
+				const globalName = `feature:${name}/${localName}`;
+				const unregisterCatalog = this.#deps.catalog.registerBucket(name, globalName, bucket);
+				rollback.push(unregisterCatalog);
+				const unregisterQueue = this.#deps.registerBucket(globalName, bucket);
+				if (unregisterQueue) rollback.push(unregisterQueue);
+				bucketNames.set(localName, globalName);
+			}
+			for (const [rawLocalName, definition] of Object.entries(feature.operations)) {
+				const localName = requireOperationName(rawLocalName, name);
+				if (typeof definition !== "object" || definition === null) throw new ItdConfigError(`feature «${name}»: операция «${localName}» должна быть объектом`);
+				if (![
+					"GET",
+					"POST",
+					"PUT",
+					"PATCH",
+					"DELETE"
+				].includes(definition.method)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестный HTTP-метод`);
+				if (!Object.values(RetrySafety).includes(definition.retrySafety)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестную retrySafety`);
+				if (definition.service !== void 0 && typeof definition.service !== "string") throw new ItdConfigError(`feature «${name}»: service операции «${localName}» должен быть строкой`);
+				if (definition.bucket !== void 0 && typeof definition.bucket !== "string") throw new ItdConfigError(`feature «${name}»: bucket операции «${localName}» должен быть строкой`);
+				if (definition.service !== void 0 && !services.has(definition.service)) throw new ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный сервис «${definition.service}»`);
+				const bucket = definition.bucket === void 0 ? this.#deps.catalog.defaultBucket : bucketNames.get(definition.bucket);
+				if (bucket === void 0) throw new ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный бакет «${definition.bucket}»`);
+				const operationId = `${name}.${localName}`;
+				const unregister = this.#deps.catalog.registerOperation(name, operationId, {
+					method: definition.method,
+					retrySafety: definition.retrySafety,
+					bucket
+				});
+				rollback.push(unregister);
+				operations.set(localName, {
+					operationId,
+					method: definition.method,
+					service: definition.service
+				});
+			}
+			const context = Object.freeze({
+				featureName: name,
+				baseUrl: this.#deps.baseUrl,
+				signal: controller.signal,
+				clock: this.#deps.clock,
+				logger: this.#deps.logger,
+				request: (operation, options) => {
+					try {
+						this.#deps.assertActive(`выполнить операцию feature «${name}»`);
+						if (!committed || controller.signal.aborted) throw new ItdStateError(`feature «${name}» не активен`);
+						const resolved = operations.get(operation);
+						if (!resolved) throw new ItdConfigError(`feature «${name}» не объявляет операцию «${operation}»`);
+						const scoped = { ...options };
+						delete scoped.operationId;
+						delete scoped.method;
+						delete scoped.service;
+						delete scoped.baseUrl;
+						delete scoped.retrySafety;
+						delete scoped.rateLimitBucket;
+						return this.#deps.http.request({
+							...scoped,
+							operationId: resolved.operationId,
+							method: resolved.method,
+							...resolved.service === void 0 ? {} : { service: resolved.service }
+						});
+					} catch (error) {
+						return Promise.reject(error);
+					}
+				},
+				serviceBaseUrl: (serviceName) => {
+					if (!services.has(serviceName)) throw new ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.services.resolveBaseUrl(serviceName);
+				}
+			});
+			const installation = feature.setup(context);
+			if (typeof installation !== "object" || installation === null || !("api" in installation)) throw new ItdConfigError(`setup() feature «${name}» должен вернуть объект с полем api`);
+			if (installation.close !== void 0 && typeof installation.close !== "function") throw new ItdConfigError(`feature «${name}»: close должен быть функцией`);
+			if (installation.dispose !== void 0 && typeof installation.dispose !== "function") throw new ItdConfigError(`feature «${name}»: dispose должен быть функцией`);
+			this.#features.set(name, {
+				name,
+				controller,
+				close: installation.close,
+				dispose: installation.dispose,
+				cleanup: [...rollback]
+			});
+			committed = true;
+			return installation.api;
+		} catch (error) {
+			controller.abort(new ItdAbortError(`Установка feature «${name}» отменена`));
+			for (const undo of rollback.reverse()) undo();
+			throw error;
+		}
+	}
+	names() {
+		return [...this.#features.keys()];
+	}
+	has(name) {
+		return this.#features.has(name);
+	}
+	async close() {
+		const errors = [];
+		for (const feature of [...this.#features.values()].reverse()) try {
+			await feature.close?.();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось закрыть feature");
+	}
+	async dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		const errors = [];
+		for (const feature of [...this.#features.values()].reverse()) {
+			feature.controller.abort(new ItdAbortError(`Feature «${feature.name}» освобождён`));
+			try {
+				await feature.dispose?.();
+			} catch (error) {
+				errors.push(error);
+			}
+			for (const cleanup of [...feature.cleanup].reverse()) try {
+				cleanup();
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		this.#features.clear();
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить feature");
+	}
+};
+//#endregion
+//#region src/resources/pagination.ts
+/** Схема пагинации эндпоинта. */
+const PaginationMode = Object.freeze({
+	/** Следующая страница запрашивается непрозрачным курсором. */
+	Cursor: "cursor",
+	/** Следующая страница запрашивается номером. */
+	Page: "page",
+	/** Следующая страница запрашивается смещением от начала списка. */
+	Offset: "offset"
+});
+/** Применяет преобразование к элементам страницы, сохраняя сведения о пагинации. */
+function mapPage(page, map) {
+	return {
+		...page,
+		items: page.items.map(map)
+	};
+}
+/**
+* Достаёт список из ответа, перебирая все формы, которые встречаются у сервера.
+*
+* Список может прийти под именем сущности, под её альтернативным именем
+* (`followers` вместо `users`) либо голым массивом.
+*
+* @param fields имена полей в порядке предпочтения
+*/
+function readItems(body, fields) {
+	if (Array.isArray(body)) return body;
+	for (const field of fields) {
+		const items = pickArray(body, field);
+		if (items.length > 0) return items;
+	}
+	const primary = fields[0];
+	return primary === void 0 ? [] : pickArray(body, primary);
+}
+/**
+* Достаёт курсор следующей страницы.
+*
+* Проверяются все известные места: внутри `pagination`, рядом со списком и во вложенном
+* объекте `meta.cursor.next`.
+*/
+function readCursor(body) {
+	const pagination = pickObject(body, "pagination");
+	const meta = pickObject(body, "meta");
+	const metaCursor = pickObject(meta, "cursor");
+	return pickString(pagination, "nextCursor") ?? pickString(body, "nextCursor") ?? pickString(body, "cursor") ?? pickString(metaCursor, "next") ?? null;
+}
+/**
+* Читает страницу курсорной схемы.
+*
+* Используется лентой, постами пользователя и постами по хэштегу.
+*
+* @param fields имена возможных полей со списком; первое — основное
+*/
+function readCursorPage(body, ...fields) {
+	const pagination = pickObject(body, "pagination");
+	const items = readItems(body, fields);
+	const nextCursor = readCursor(body);
+	return {
+		items,
+		hasMore: pickBoolean(pagination, "hasMore", pickBoolean(body, "hasMore", nextCursor !== null)),
+		nextCursor,
+		limit: pickNumber(pagination, "limit", 0) || void 0,
+		raw: body
+	};
+}
+/**
+* Читает страницу курсорной схемы с курсором рядом со списком.
+*
+* Так устроены комментарии к посту и ответы на комментарий: `nextCursor` и `hasMore`
+* лежат на одном уровне со списком, а не внутри объекта `pagination`.
+*/
+function readFlatCursorPage(body, ...fields) {
+	const items = readItems(body, fields);
+	const nextCursor = readCursor(body);
+	const total = pickNumber(body, "total", -1);
+	return {
+		items,
+		hasMore: pickBoolean(body, "hasMore", nextCursor !== null),
+		nextCursor,
+		...total >= 0 ? { total } : {},
+		raw: body
+	};
+}
+/**
+* Читает страницу постраничной схемы: `data.pagination.{page,limit,total,hasMore}`.
+*
+* Если сервер вместо этого прислал курсор, он тоже подхватывается — некоторые списки
+* отвечают в курсорной форме, хотя документация описывает постраничную.
+*/
+function readPagedPage(body, ...fields) {
+	const pagination = pickObject(body, "pagination");
+	const items = readItems(body, fields);
+	const nextCursor = readCursor(body);
+	return {
+		items,
+		hasMore: pickBoolean(pagination, "hasMore", pickBoolean(body, "hasMore", nextCursor !== null)),
+		page: pickNumber(pagination, "page", 1),
+		limit: pickNumber(pagination, "limit", 0) || void 0,
+		total: pickNumber(pagination, "total", 0),
+		...nextCursor !== null ? { nextCursor } : {},
+		raw: body
+	};
+}
+/**
+* Читает страницу схемы со смещением.
+*
+* Используется для списков со смещением, включая уведомления.
+*/
+function readOffsetPage(body, field, offset) {
+	const items = pickArray(body, field);
+	return {
+		items,
+		hasMore: pickBoolean(body, "hasMore"),
+		nextOffset: offset + items.length,
+		raw: body
+	};
+}
+/**
+* Перебор страниц списка.
+*
+* Скрывает различия трёх схем пагинации: перебор элементов, страниц и сбор в массив
+* выглядят одинаково независимо от эндпоинта.
+*
+* **Одноразовый.** Позиция хранится внутри, поэтому повторный перебор того же объекта
+* ничего не вернёт: он продолжится с места, где закончился прошлый. Нужен второй проход —
+* возьмите новый перебор у того же метода ресурса.
+*
+* @example Перебор элементов
+* ```ts
+* for await (const post of itd.posts.iterate({ tab: 'following' })) {
+*   console.log(post.content);
+* }
+* ```
+*
+* @example Первые сто элементов
+* ```ts
+* const posts = await itd.posts.iterate({ tab: 'popular' }).collect(100);
+* ```
+*
+* @example Постранично
+* ```ts
+* for await (const page of itd.users.followers('nowkie').pages()) {
+*   console.log(page.items.length, 'из', page.total);
+* }
+* ```
+*/
+var Paginator = class {
+	#options;
+	#maxPages;
+	#state;
+	#finished = false;
+	#pagesLoaded = 0;
+	constructor(options) {
+		if (options.maxPages !== void 0 && (!Number.isInteger(options.maxPages) || options.maxPages < 1)) throw new ItdConfigError(`maxPages должен быть целым числом не меньше 1, получено: ${options.maxPages}`);
+		this.#options = options;
+		this.#maxPages = options.maxPages ?? 1e3;
+		this.#state = options.start ?? {};
+	}
+	/**
+	* Загружает следующую страницу.
+	*
+	* @returns страница либо `null`, если перебор закончен
+	*/
+	async next() {
+		if (this.#finished) return null;
+		if (this.#options.signal?.aborted) return null;
+		if (this.#pagesLoaded >= this.#maxPages) {
+			this.#finished = true;
+			return null;
+		}
+		const previous = this.#state;
+		const page = await this.#options.load(previous);
+		this.#pagesLoaded += 1;
+		this.#state = this.#advance(previous, page);
+		return page;
+	}
+	/**
+	* Перебирает страницы целиком.
+	*
+	* Полезно, когда нужны сведения о самой странице — например `total`.
+	*/
+	async *pages() {
+		for (;;) {
+			const page = await this.next();
+			if (!page) return;
+			yield page;
+		}
+	}
+	/** Перебирает элементы всех страниц подряд. */
+	async *[Symbol.asyncIterator]() {
+		for await (const page of this.pages()) for (const item of page.items) {
+			if (this.#options.signal?.aborted) return;
+			yield item;
+		}
+	}
+	/**
+	* Собирает элементы в массив.
+	*
+	* @param max сколько элементов достаточно; без него перебираются все страницы
+	*/
+	async collect(max) {
+		if (max !== void 0 && max <= 0) return [];
+		const result = [];
+		for await (const item of this) {
+			result.push(item);
+			if (max !== void 0 && result.length >= max) break;
+		}
+		return result;
+	}
+	/**
+	* Вычисляет позицию следующей страницы и решает, продолжать ли.
+	*
+	* Здесь же стоят предохранители: пустая страница при `hasMore`, неизменившийся курсор
+	* и отсутствие курсора останавливают перебор. Без них ошибка на сервере превратилась бы
+	* в бесконечный цикл запросов.
+	*/
+	#advance(previous, page) {
+		if (!page.hasMore || page.items.length === 0) {
+			this.#finished = true;
+			return previous;
+		}
+		if (this.#options.mode === PaginationMode.Cursor) {
+			const cursor = page.nextCursor ?? void 0;
+			if (!cursor || cursor === previous.cursor) {
+				this.#finished = true;
+				return previous;
+			}
+			return { cursor };
+		}
+		if (this.#options.mode === PaginationMode.Page) return { page: (previous.page ?? 1) + 1 };
+		return { offset: page.nextOffset ?? (previous.offset ?? 0) + page.items.length };
+	}
+};
+//#endregion
+//#region src/resources/base.ts
+/** Общая основа всех групп методов клиента. */
+var BaseResource = class {
+	/** @internal */
+	http;
+	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 } : {}
+		});
+	}
+	/**
+	* Собирает пару «загрузка страницы + перебор» из одного описания.
+	*
+	* Путь, параметры запроса и разбор ответа задаются один раз; `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)
+				});
+			}
+		};
+	}
+};
+/** Добавляет позицию страницы в параметры запроса. */
+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/domain/time.ts
+const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+/**
+* Приводит отметку времени без часового пояса к ISO-8601, считая её временем UTC.
+*
+* Строку другого вида возвращает нетронутой.
+*
+* @example
+* ```ts
+* utcStampToIso('2026-07-23 23:14:25');  // '2026-07-23T23:14:25Z'
+* utcStampToIso('2026-07-23T23:14:25Z'); // без изменений
+* ```
+*/
+function utcStampToIso(value) {
+	const match = typeof value === "string" ? NAIVE_STAMP.exec(value) : null;
+	if (!match) return value;
+	const iso = `${match[1]}T${match[2]}Z`;
+	return Number.isFinite(Date.parse(iso)) ? iso : value;
+}
+/**
+* Разбирает дату API в объект `Date`.
+*
+* @returns `null`, если строки нет или она не разбирается
+*
+* @example
+* ```ts
+* const created = toDate(post.createdAt);
+* ```
+*/
+function toDate(value) {
+	if (!value) return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date : null;
+}
+//#endregion
+//#region src/resources/status.ts
+/** Приводит `last_checked` каждого сервиса к ISO. Остальное остаётся как прислал сервер. */
+function normalizeStatus(body) {
+	if (!isRecord(body) || !Array.isArray(body.services)) return body;
+	return {
+		...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;
+	}
+	async get(options = {}) {
+		return normalizeStatus(await this.#context.request("get", {
+			path: "/api/status",
+			...options
+		}));
+	}
+};
+/** Встроенный модуль страницы состояния платформы. @internal */
+function createStatusFeature() {
+	return {
+		name: "status",
+		services: [{
+			name: STATUS_SERVICE,
+			baseUrl: DEFAULT_STATUS_BASE_URL,
+			auth: false
+		}],
+		operations: { get: {
+			method: "GET",
+			retrySafety: RetrySafety.Safe,
+			service: STATUS_SERVICE
+		} },
+		setup: (context) => ({ api: new StatusResource(context) })
+	};
+}
+//#endregion
+//#region src/builders/base.ts
+/** Метка билдера. Через `Symbol.for` — чтобы распознавание переживало смешивание ESM и CJS. */
+const BUILDER = Symbol.for("itd.builder");
+/** Является ли значение билдером. */
+function isBuilder(value) {
+	return typeof value === "object" && value !== null && BUILDER in value;
+}
+/**
+* Приводит любую из трёх форм входа к готовому объекту.
+*
+* Проверка выполняется всегда, независимо от формы: обычный объект проходит ровно те же
+* правила, что и результат билдера.
+*
+* @param input то, что передал пользователь
+* @param factory создаёт пустой билдер для формы с функцией
+* @param validate проверяет собранный объект
+*/
+function resolveInput(input, factory, validate) {
+	if (typeof input === "function") {
+		const result = input(factory());
+		return isBuilder(result) ? result.build() : validate(result);
+	}
+	if (isBuilder(input)) return input.build();
+	return validate(input);
+}
+//#endregion
+//#region src/builders/comment.ts
+/**
+* Проверяет данные комментария.
+*
+* @throws {ItdConfigError} если комментарий пуст или голосовой собран неверно
+*/
+function validateComment(input) {
+	const content = typeof input?.content === "string" ? input.content : "";
+	const attachmentIds = input?.attachmentIds ?? [];
+	const files = input?.files ?? [];
+	const hasContent = content.trim() !== "";
+	const hasAttachments = attachmentIds.length > 0 || files.length > 0;
+	if (!hasContent && !hasAttachments) throw new ItdConfigError("Комментарий пуст: нужен текст или вложение");
+	return input;
+}
+/** Дополнительная проверка голосового комментария. */
+function validateVoice(state) {
+	if (state.content.trim() !== "") throw new ItdConfigError("У голосового комментария не может быть текста: API принимает либо текст, либо аудио");
+	const total = state.files.length + state.attachmentIds.length;
+	if (total !== 1) throw new ItdConfigError(`Голосовой комментарий требует ровно одно аудиовложение, передано: ${total}`);
+}
+/**
+* Билдер комментария и ответа на комментарий.
+*
+* Неизменяемый: каждый вызов возвращает новый экземпляр. Создаётся функцией {@link comment}.
+*/
+var CommentBuilder = class CommentBuilder {
+	/** @internal */
+	[BUILDER] = true;
+	#state;
+	/** @internal Создавайте билдер функцией {@link comment}. */
+	constructor(state) {
+		this.#state = state;
+	}
+	/** Задаёт текст комментария. */
+	content(text) {
+		return new CommentBuilder({
+			...this.#state,
+			content: text
+		});
+	}
+	/** Прикладывает файл — он будет загружен перед отправкой. */
+	attach(file) {
+		return new CommentBuilder({
+			...this.#state,
+			files: [...this.#state.files, file]
+		});
+	}
+	/** Прикладывает уже загруженное вложение. */
+	attachId(attachmentId) {
+		return new CommentBuilder({
+			...this.#state,
+			attachmentIds: [...this.#state.attachmentIds, attachmentId]
+		});
+	}
+	/**
+	* Делает комментарий голосовым.
+	*
+	* Текста у такого комментария быть не должно, а вложение ровно одно — аудио в формате
+	* `audio/ogg`. Так его принимает API.
+	*
+	* @example
+	* ```ts
+	* import { fromPath } from 'itd-api/node';
+	*
+	* await itd.posts.comment(postId, (c) => c.voice(fromPath('./answer.ogg')));
+	* ```
+	*/
+	voice(audio) {
+		return new CommentBuilder({
+			...this.#state,
+			files: [audio],
+			voice: true
+		});
+	}
+	/**
+	* Кому адресован ответ.
+	*
+	* Имеет смысл только в `itd.comments.reply()`; при отправке комментария к посту
+	* это поле вызовет ошибку.
+	*/
+	replyTo(userId) {
+		return new CommentBuilder({
+			...this.#state,
+			replyToUserId: userId
+		});
+	}
+	build() {
+		const { content, attachmentIds, files, voice, ...rest } = this.#state;
+		if (voice) validateVoice(this.#state);
+		return validateComment({
+			...rest,
+			content,
+			...attachmentIds.length > 0 ? { attachmentIds } : {},
+			...files.length > 0 ? { files } : {}
+		});
+	}
+	toJSON() {
+		return this.build();
+	}
+};
+/**
+* Начинает сборку комментария.
+*
+* @param content текст; можно задать позже методом {@link CommentBuilder.content}
+*
+* @example
+* ```ts
+* import { comment } from 'itd-api';
+*
+* await itd.posts.comment(postId, comment('согласен').attach({ url: memeUrl }));
+* ```
+*/
+function comment(content = "") {
+	return new CommentBuilder({
+		content,
+		attachmentIds: [],
+		files: [],
+		voice: false
+	});
+}
+/**
+* Приводит любую форму входа к готовым данным комментария.
+*
+* @param allowReplyTo разрешено ли поле `replyToUserId`; в комментарии к посту — нет
+*/
+function resolveComment(input, allowReplyTo = false) {
+	const resolved = resolveInput(input, () => comment(), validateComment);
+	if (!allowReplyTo && resolved.replyToUserId !== void 0) throw new ItdConfigError("replyTo применим только к ответу на комментарий (itd.comments.reply). В комментарии к посту адресат не указывается.");
+	return resolved;
+}
+//#endregion
+//#region src/resources/comments.ts
+/**
+* Комментарии и ответы на них.
+*
+* Доступна как `itd.comments`. Комментарии **к посту** живут в `itd.posts`:
+* `itd.posts.comments()` и `itd.posts.comment()`.
+*/
+var CommentsResource = class extends BaseResource {
+	#uploadFiles;
+	/** Ответы на комментарий: `/api/comments/{id}/replies`, постраничная пагинация. */
+	#replies = this.paginated({
+		operationId: "comments.replies",
+		path: (p) => `/api/comments/${encodePathSegment(p.commentId, "commentId")}/replies`,
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => p.page !== void 0 ? { page: p.page } : {},
+		read: (body) => readPagedPage(body, "replies"),
+		mode: PaginationMode.Page
+	});
+	constructor(http, deps) {
+		super(http);
+		this.#uploadFiles = deps.uploadFiles;
+	}
+	/**
+	* Загружает страницу ответов на комментарий.
+	*
+	* Здесь пагинация **постраничная**, в отличие от комментариев к посту, где курсорная.
+	*/
+	replies(commentId, params = {}, options = {}) {
+		return this.#replies.list({
+			...params,
+			commentId
+		}, options);
+	}
+	/** Перебирает ответы на комментарий. */
+	iterateReplies(commentId, params = {}, options = {}) {
+		return this.#replies.iterate({
+			...params,
+			commentId
+		}, options);
+	}
+	/**
+	* Отвечает на комментарий.
+	*
+	* @example
+	* ```ts
+	* await itd.comments.reply(commentId, 'согласен');
+	* await itd.comments.reply(commentId, (c) => c.content('и вот почему').replyTo(userId));
+	* ```
+	*/
+	async reply(commentId, input, options = {}) {
+		const data = resolveComment(typeof input === "string" ? { content: input } : input, true);
+		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/${encodePathSegment(commentId, "commentId")}/replies`,
+			body: {
+				content: data.content ?? "",
+				attachmentIds,
+				...data.replyToUserId ? { replyToUserId: data.replyToUserId } : {}
+			},
+			...options
+		});
+	}
+	/** Редактирует текст комментария. */
+	update(commentId, content, options = {}) {
+		return this.http.operation("comments.update", {
+			path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
+			body: { content },
+			...options
+		});
+	}
+	/** Удаляет комментарий. Восстановить его можно через {@link restore}. */
+	remove(commentId, options = {}) {
+		return this.http.operation("comments.remove", {
+			path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
+			...options
+		});
+	}
+	/** Восстанавливает удалённый комментарий. */
+	restore(commentId, options = {}) {
+		return this.http.operation("comments.restore", {
+			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/restore`,
+			...options
+		});
+	}
+	/** Ставит реакцию на комментарий. */
+	like(commentId, options = {}) {
+		return this.http.operation("comments.like", {
+			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
+			...options
+		});
+	}
+	/** Убирает реакцию с комментария. */
+	unlike(commentId, options = {}) {
+		return this.http.operation("comments.unlike", {
+			path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/core/attachments/url-source.ts
+/** Убирает параметры MIME и приводит его к форме для сравнения. */
+function normalizeMimeType(contentType) {
+	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
+}
+/** Достаёт имя файла из пути URL. */
+function filenameFromUrl(url) {
+	const last = url.pathname.split("/").pop();
+	if (!last) return void 0;
+	try {
+		return decodeURIComponent(last) || void 0;
+	} catch {
+		return last;
+	}
+}
+/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
+function declaredSize(response, maxBytes, url) {
+	const header = response.headers.get("content-length");
+	if (header === null) return void 0;
+	const size = Number(header);
+	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
+	if (maxBytes !== void 0 && size > maxBytes) throw fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new ItdConfigError(`«${target}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
+	let response;
+	try {
+		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
+	} catch (error) {
+		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
+		throw new ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
+			reason: ItdFileErrorReason.Network,
+			url: requested.href,
+			retryable: true,
+			cause: error
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		throw new ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
+			reason: ItdFileErrorReason.Http,
+			url: finalUrl.href,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	let size;
+	try {
+		size = declaredSize(response, maxBytes, finalUrl.href);
+	} catch (error) {
+		await response.body?.cancel().catch(() => {});
+		throw error;
+	}
+	return {
+		response,
+		url: finalUrl,
+		size
+	};
+}
+/** Читает ответ с контролем размера до создания итогового `Blob`. */
+async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
+	if (!response.body) {
+		const blob = await response.blob();
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url } = await fetchFile(target, options, context);
+	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	const filename = options.filename ?? filenameFromUrl(url);
+	return {
+		file: new Blob([blob], { type: contentType ?? "" }),
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+/** Открывает HTTP-ответ как ограниченный поток. @internal */
+async function openUrlFile(target, options, context) {
+	const resolved = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) throw new ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
+		reason: ItdFileErrorReason.StreamUnavailable,
+		url: url.href
+	});
+	const stream = boundedFileStream(response.body, {
+		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+		streamBufferBytes: resolved.streamBufferBytes,
+		...context.signal ? { signal: context.signal } : {},
+		url: url.href,
+		retryableRead: true
+	});
+	const filename = options.filename ?? filenameFromUrl(url);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	return {
+		stream,
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {},
+		...size !== void 0 ? { size } : {},
+		close: () => stream.cancel().catch(() => {})
+	};
+}
+//#endregion
+//#region src/core/multipart.ts
+const encoder = new TextEncoder();
+/** Убирает возможность внедрить дополнительный multipart-заголовок через имя файла. */
+function quotedFilename(filename) {
+	return filename.replace(/[\r\n]/g, "").replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+/** Удаляет разделители строк, чтобы значение не создало новый multipart-заголовок. */
+function headerValue(value) {
+	return value.replace(/[\r\n]/g, "");
+}
+/** Создаёт уникальную границу без зависимости от Web Crypto. */
+function boundary() {
+	return `----itd-api-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+/**
+* Кодирует один файл в multipart без полной буферизации.
+*
+* Читает следующий чанк только когда потребитель запросил данные.
+*/
+function createMultipartFileBody(file) {
+	const marker = boundary();
+	const prefix = encoder.encode(`--${marker}\r\nContent-Disposition: form-data; name="file"; filename="${quotedFilename(file.filename)}"\r\nContent-Type: ${headerValue(file.contentType)}\r\n\r\n`);
+	const suffix = encoder.encode(`\r\n--${marker}--\r\n`);
+	const reader = file.stream.getReader();
+	let stage = "prefix";
+	let cancelled = false;
+	const cancel = async (reason) => {
+		if (cancelled) return;
+		cancelled = true;
+		await reader.cancel(reason).catch(() => {});
+	};
+	return {
+		body: new ReadableStream({
+			async pull(controller) {
+				if (stage === "prefix") {
+					stage = "file";
+					controller.enqueue(prefix);
+					return;
+				}
+				if (stage === "file") try {
+					const next = await reader.read();
+					if (!next.done) {
+						controller.enqueue(next.value);
+						return;
+					}
+					stage = "suffix";
+				} catch (error) {
+					stage = "done";
+					controller.error(error);
+					return;
+				}
+				if (stage === "suffix") {
+					stage = "done";
+					controller.enqueue(suffix);
+					controller.close();
+				}
+			},
+			cancel
+		}),
+		contentType: `multipart/form-data; boundary=${marker}`,
+		cancel
+	};
+}
+//#endregion
+//#region src/domain/mime.ts
+/** Изображения, которые принимает `POST /api/files/upload`. */
+const IMAGE_MIME_TYPES = Object.freeze([
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"image/avif",
+	"image/heic",
+	"image/heif"
+]);
+/** Видео, которые принимает `POST /api/files/upload`. */
+const VIDEO_MIME_TYPES = Object.freeze([
+	"video/mp4",
+	"video/webm",
+	"video/quicktime"
+]);
+/** Аудио для голосовых комментариев. */
+const AUDIO_MIME_TYPES = Object.freeze(["audio/ogg"]);
+/** Все типы, которые принимает загрузка. */
+const ALLOWED_MIME_TYPES = Object.freeze([
+	...IMAGE_MIME_TYPES,
+	...VIDEO_MIME_TYPES,
+	...AUDIO_MIME_TYPES
+]);
+/**
+* Соответствие расширения и MIME-типа.
+*
+* Своя маленькая таблица вместо зависимости: библиотеке нужны ровно те типы,
+* которые принимает API.
+*/
+const EXTENSION_TO_MIME = Object.freeze({
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	jfif: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	avif: "image/avif",
+	heic: "image/heic",
+	heif: "image/heif",
+	mp4: "video/mp4",
+	m4v: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	qt: "video/quicktime",
+	ogg: "audio/ogg",
+	oga: "audio/ogg",
+	opus: "audio/ogg"
+});
+/** Определяет MIME-тип по расширению имени файла. */
+function mimeFromFilename(filename) {
+	const dot = filename.lastIndexOf(".");
+	if (dot < 0) return void 0;
+	return EXTENSION_TO_MIME[filename.slice(dot + 1).toLowerCase()];
+}
+/** Разрешён ли тип к загрузке. */
+function isAllowedMime(mimeType) {
+	return ALLOWED_MIME_TYPES.includes(mimeType.toLowerCase());
+}
+/**
+* Проверяет тип файла до отправки.
+*
+* Отказ на стороне клиента экономит и время, и трафик: тот же `UNSUPPORTED_FILE_TYPE`
+* пришёл бы с сервера, но уже после загрузки всего файла.
+*
+* @throws {ItdConfigError} если тип не поддерживается
+*/
+function assertAllowedMime(mimeType, filename) {
+	if (!mimeType) throw new ItdConfigError(`Не удалось определить тип файла${filename ? ` «${filename}»` : ""}. Укажите его явно: { file, filename, contentType }.`);
+	if (!isAllowedMime(mimeType)) throw new ItdConfigError(`Тип «${mimeType}» не поддерживается загрузкой. Допустимые: ${ALLOWED_MIME_TYPES.join(", ")}.`);
+}
+/** Файлы и медиа. */
+var FilesResource = class extends BaseResource {
+	#fetch;
+	constructor(http, deps) {
+		super(http);
+		this.#fetch = deps.fetch;
+	}
+	/**
+	* Загружает файл и возвращает его идентификатор.
+	*
+	* Потоковый источник открывается заново при каждой повторной попытке. Буферный источник
+	* после успешного чтения переиспользуется.
+	*/
+	upload(input, uploadOptions = {}, requestOptions = {}) {
+		const bodyFactory = this.#createBodyFactory(input, uploadOptions);
+		return this.http.operation("files.upload", {
+			path: "/api/files/upload",
+			bodyFactory,
+			...requestOptions,
+			timeout: requestOptions.timeout ?? 3e5
+		});
+	}
+	/** Загружает несколько файлов последовательно, сохраняя порядок. */
+	async uploadMany(files, uploadOptions = {}, requestOptions = {}) {
+		const ids = [];
+		for (const file of files) ids.push((await this.upload(file, uploadOptions, requestOptions)).id);
+		return ids;
+	}
+	/**
+	* Загружает сведения о файле.
+	*
+	* Для ещё не прикреплённого файла сервер может ответить `404`.
+	*/
+	get(fileId, options = {}) {
+		return this.http.operation("files.get", {
+			path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
+			...options
+		});
+	}
+	/** Удаляет загруженный файл. */
+	remove(fileId, options = {}) {
+		return this.http.operation("files.remove", {
+			path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
+			...options
+		});
+	}
+	/**
+	* Создаёт фабрику тела. Успешно подготовленный буфер кешируется, а поток открывается
+	* заново, поэтому каждая транспортная попытка получает непрочитанное тело.
+	*/
+	#createBodyFactory(input, options) {
+		const streamMode = this.#isStreamInput(input);
+		let buffered;
+		return async ({ signal, attempt }) => {
+			const context = {
+				fetch: this.#fetch,
+				signal,
+				attempt
+			};
+			let prepared;
+			try {
+				if (streamMode) prepared = await this.#prepareStream(input, options, context);
+				else {
+					buffered ??= this.#prepareBuffer(input, options, context).catch((error) => {
+						buffered = void 0;
+						throw error;
+					});
+					prepared = await buffered;
+				}
+			} catch (error) {
+				if (error instanceof ItdError || signal.aborted) throw error;
+				throw new ItdFileError("не удалось получить содержимое вложения", {
+					reason: ItdFileErrorReason.Read,
+					retryable: true,
+					cause: error
+				});
+			}
+			if (prepared.mode === "buffer") {
+				const form = new FormData();
+				form.set("file", prepared.blob, prepared.filename);
+				return { body: form };
+			}
+			const multipart = createMultipartFileBody(prepared);
+			return {
+				body: multipart.body,
+				headers: { "Content-Type": multipart.contentType },
+				cleanup: async () => {
+					await multipart.cancel();
+					await prepared.close?.();
+				}
+			};
+		};
+	}
+	/** Определяет режим без чтения источника. */
+	#isStreamInput(input) {
+		if (typeof input !== "object" || input === null) return false;
+		if ("open" in input) return true;
+		if ("url" in input) return resolveFileStreamOptions(input).mode === FileTransferMode.Stream;
+		return false;
+	}
+	/** Получает и проверяет буферный источник. */
+	async #prepareBuffer(input, options, context) {
+		const content = await this.#resolveBuffer(input, context);
+		const filename = options.filename ?? content.filename ?? this.#nameFromMime(options.contentType ?? content.contentType);
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
+		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+		const blob = isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
+		const limits = resolveFileStreamOptions(options);
+		if (limits.maxBytes !== void 0 && blob.size > limits.maxBytes) throw new ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${blob.size}`, {
+			reason: ItdFileErrorReason.TooLarge,
+			limit: limits.maxBytes,
+			actual: blob.size
+		});
+		return {
+			mode: "buffer",
+			blob,
+			filename
+		};
+	}
+	/** Открывает и проверяет потоковый источник. */
+	async #prepareStream(input, options, context) {
+		let opened;
+		if (typeof input === "object" && input !== null && "open" in input) opened = await input.open(context);
+		else if (typeof input === "object" && input !== null && "url" in input) {
+			const { url, ...urlOptions } = input;
+			opened = await openUrlFile(url, urlOptions, context);
+		} else throw new ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
+		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
+			await opened?.close?.();
+			throw new ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
+		}
+		try {
+			const filename = options.filename ?? opened.filename ?? this.#nameFromMime(options.contentType ?? opened.contentType);
+			const contentType = normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
+			if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+			const limits = resolveFileStreamOptions({
+				mode: FileTransferMode.Stream,
+				...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
+				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
+			});
+			if (limits.maxBytes !== void 0 && opened.size !== void 0 && opened.size > limits.maxBytes) throw new ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${opened.size}`, {
+				reason: ItdFileErrorReason.TooLarge,
+				limit: limits.maxBytes,
+				actual: opened.size
+			});
+			return {
+				mode: "stream",
+				stream: isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : boundedFileStream(opened.stream, {
+					...limits.maxBytes !== void 0 ? { maxBytes: limits.maxBytes } : {},
+					streamBufferBytes: limits.streamBufferBytes,
+					signal: context.signal
+				}),
+				filename,
+				contentType: contentType ?? "",
+				...opened.close ? { close: opened.close } : {}
+			};
+		} catch (error) {
+			await opened.close?.();
+			throw error;
+		}
+	}
+	/** Разрешает только буферные формы. */
+	#resolveBuffer(input, context) {
+		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || isBlob(input)) return {
+			file: input,
+			...isFile(input) ? { filename: input.name } : {}
+		};
+		if (typeof input !== "object" || input === null) throw new ItdConfigError(`вложение задано значением типа ${typeof input}; ожидается бинарное значение или объект { file }, { url }, { load }, { open }. Для файла на диске используйте fromPath('./photo.jpg') из itd-api/node`);
+		if ("load" in input) return input.load(context);
+		if ("url" in input) {
+			const { url, ...urlOptions } = input;
+			return downloadFile(url, urlOptions, context);
+		}
+		if ("file" in input) return input;
+		if ("open" in input) throw new ItdConfigError("потоковый источник нельзя использовать как буферный");
+		throw new ItdConfigError("вложение не распознано: ожидается { file }, { url }, { load } или { open }");
+	}
+	/** Подбирает непустое имя, обязательное для multipart. */
+	#nameFromMime(contentType) {
+		const extension = normalizeMimeType(contentType)?.split("/")[1];
+		return extension ? `file.${extension}` : "file";
+	}
+};
+//#endregion
+//#region src/resources/hashtags.ts
+/**
+* Хэштеги.
+*
+* Доступна как `itd.hashtags`.
+*/
+var HashtagsResource = class extends BaseResource {
+	/** Посты по хэштегу: `/api/hashtags/{tag}/posts`, курсорная пагинация. */
+	#posts = this.paginated({
+		operationId: "hashtags.posts",
+		path: (p) => `/api/hashtags/${encodePathSegment(p.tag, "tag")}/posts`,
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => p.cursor ? { cursor: p.cursor } : {},
+		read: (body) => readCursorPage(body, "posts"),
+		mode: PaginationMode.Cursor
+	});
+	/**
+	* Ищет хэштеги.
+	*
+	* Без строки запроса возвращает общий список.
+	*/
+	async search(query, params = {}, options = {}) {
+		const body = await this.http.operation("hashtags.search", {
+			path: "/api/hashtags",
+			query: {
+				q: query,
+				limit: params.limit
+			},
+			...options
+		});
+		return pickArray(body, "hashtags");
+	}
+	/** Загружает трендовые хэштеги. */
+	async trending(params = {}, options = {}) {
+		const body = await this.http.operation("hashtags.trending", {
+			path: "/api/hashtags/trending",
+			query: { limit: params.limit },
+			...options
+		});
+		return pickArray(body, "hashtags");
+	}
+	/**
+	* Загружает страницу постов по хэштегу.
+	*
+	* @param tag название без решётки; кодируется автоматически, поэтому кириллица
+	* и пробелы допустимы
+	*/
+	posts(tag, params = {}, options = {}) {
+		return this.#posts.list({
+			...params,
+			tag
+		}, options);
+	}
+	/** Перебирает посты по хэштегу. */
+	iteratePosts(tag, params = {}, options = {}) {
+		return this.#posts.iterate({
+			...params,
+			tag
+		}, options);
+	}
+};
+//#endregion
+//#region src/resources/notifications.ts
+const NOTIFICATION_SETTING_KEYS = [
+	"enabled",
+	"sound",
+	"follows",
+	"wallPosts",
+	"likes",
+	"comments",
+	"mentions"
+];
+/**
+* Сколько идентификаторов уходит в одном запросе на отметку прочтения.
+*
+* Столько же отправляет сайт итд.com — значит на сервере, скорее всего, есть ограничение.
+*/
+const READ_BATCH_SIZE = 20;
+/**
+* Читает настройки уведомлений.
+*
+* Сервер отдаёт плоский объект: `enabled`, `sound`, `follows`, `wallPosts`, `likes`,
+* `comments`, `mentions`. Отсутствующая настройка считается включённой — так же
+* ведёт себя сайт итд.com.
+*/
+function readSettings(body) {
+	const settings = {};
+	for (const key of NOTIFICATION_SETTING_KEYS) settings[key] = pickBoolean(body, key, true);
+	return settings;
+}
+/**
+* Уведомления: список, счётчик, отметки о прочтении, настройки.
+*
+* Доступна как `itd.notifications`. Все уведомления приведены к единой форме, поэтому
+* объекты отсюда и из потока событий можно складывать в один список.
+*/
+var NotificationsResource = class extends BaseResource {
+	/** Уведомления: `/api/notifications/`, пагинация по смещению. */
+	#list = this.paginated({
+		operationId: "notifications.list",
+		path: () => "/api/notifications/",
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => ({ offset: p.offset ?? 0 }),
+		read: (body, state) => {
+			const page = readOffsetPage(body, "notifications", state.offset ?? 0);
+			return {
+				...page,
+				items: page.items.map(normalizeNotification)
+			};
+		},
+		mode: PaginationMode.Offset
+	});
+	/**
+	* Загружает страницу уведомлений.
+	*
+	* Пагинация здесь основана на смещении.
+	*
+	* @example
+	* ```ts
+	* const page = await itd.notifications.list({ limit: 20 });
+	* const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
+	* ```
+	*/
+	list(params = {}, options = {}) {
+		return this.#list.list(params, options);
+	}
+	/**
+	* Перебирает уведомления.
+	*
+	* @example
+	* ```ts
+	* for await (const notification of itd.notifications.iterate()) {
+	*   console.log(formatNotificationText(notification));
+	* }
+	* ```
+	*/
+	iterate(params = {}, options = {}) {
+		return this.#list.iterate(params, options);
+	}
+	/** Загружает число непрочитанных уведомлений. */
+	async count(options = {}) {
+		const body = await this.http.operation("notifications.count", {
+			path: "/api/notifications/count",
+			...options
+		});
+		return pickNumber(body, "count", 0);
+	}
+	/**
+	* Отмечает уведомление прочитанным.
+	*
+	* @returns сколько записей отметил сервер
+	*/
+	async markRead(notificationId, options = {}) {
+		const body = await this.http.operation("notifications.markRead", {
+			path: `/api/notifications/${encodePathSegment(notificationId, "notificationId")}/read`,
+			...options
+		});
+		return pickNumber(body, "markedCount", 0);
+	}
+	/**
+	* Отмечает прочитанными сразу несколько уведомлений.
+	*
+	* Список автоматически режется на части по 20 идентификаторов — столько же отправляет
+	* сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
+	* результат суммируется.
+	*
+	* @returns сколько записей отметил сервер суммарно
+	*/
+	async markReadBatch(ids, options = {}) {
+		let marked = 0;
+		for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
+			const chunk = ids.slice(index, index + READ_BATCH_SIZE);
+			const body = await this.http.operation("notifications.markReadBatch", {
+				path: "/api/notifications/read-batch",
+				body: { ids: chunk },
+				...options
+			});
+			marked += pickNumber(body, "markedCount", 0);
+		}
+		return marked;
+	}
+	/** Отмечает прочитанными все уведомления. */
+	async markAllRead(options = {}) {
+		const body = await this.http.operation("notifications.markAllRead", {
+			path: "/api/notifications/read-all",
+			...options
+		});
+		return pickNumber(body, "markedCount", 0);
+	}
+	/** Загружает настройки уведомлений. */
+	async getSettings(options = {}) {
+		return readSettings(await this.http.operation("notifications.getSettings", {
+			path: "/api/notifications/settings",
+			...options
+		}));
+	}
+	/**
+	* Обновляет настройки уведомлений.
+	*
+	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
+	*/
+	async updateSettings(input, options = {}) {
+		const payload = {};
+		for (const key of NOTIFICATION_SETTING_KEYS) {
+			const value = input[key];
+			if (value !== void 0) payload[key] = value;
+		}
+		return readSettings(await this.http.operation("notifications.updateSettings", {
+			path: "/api/notifications/settings",
+			body: payload,
+			...options
+		}));
+	}
+};
+//#endregion
+//#region src/resources/platform.ts
+/**
+* Сведения о платформе: версии приложений, изменения, анонсы, баннер события.
+*
+* Доступна как `itd.platform`.
+*/
+var PlatformResource = class extends BaseResource {
+	#status;
+	/** @internal */
+	constructor(http, status) {
+		super(http);
+		this.#status = status;
+	}
+	/**
+	* Загружает минимальные и актуальные версии клиентских приложений.
+	*
+	* Endpoint публичный: автоматическая авторизация в запрос не добавляется.
+	*
+	* @example
+	* ```ts
+	* const versions = await itd.platform.version();
+	* console.log(versions.android.latestVersion);
+	* ```
+	*/
+	version(options = {}) {
+		return this.http.operation("platform.version", {
+			path: "/api/platform/version",
+			skipAuth: true,
+			...options
+		});
+	}
+	/** Загружает журнал изменений. */
+	async changelog(options = {}) {
+		const body = await this.http.operation("platform.changelog", {
+			path: "/api/platform/changelog",
+			...options
+		});
+		return Array.isArray(body) ? body : [];
+	}
+	/** Загружает анонсы платформы. */
+	async announcements(options = {}) {
+		const body = await this.http.operation("platform.announcements", {
+			path: "/api/platform/announcements",
+			...options
+		});
+		return pickArray(body, "announcements");
+	}
+	/** Загружает баннер текущего события — виджет «портал». */
+	portal(options = {}) {
+		return this.http.operation("platform.portal", {
+			path: "/api/v1/portal",
+			...options
+		});
+	}
+	/**
+	* Загружает состояние сервисов платформы за последние 90 суток.
+	*
+	* Идёт на хост `статус.итд.com` без авторизации. Ответ кэшируется сервером на минуту.
+	* История по суткам приходит разреженной, ровный массив даёт `statusDays`.
+	*
+	* @example
+	* ```ts
+	* const status = await itd.platform.status();
+	*
+	* if (status.overall_status !== 'operational') {
+	*   const broken = status.services.filter((s) => s.current_status !== 'operational');
+	*   console.log('лежит:', broken.map((s) => s.name).join(', '));
+	* }
+	* ```
+	*/
+	async status(options = {}) {
+		return this.#status.get(options);
+	}
+};
+//#endregion
+//#region src/spans/validate.ts
+/**
+* Проверяет, что spans целиком лежат внутри текста.
+*
+* Возвращает копии, чтобы последующая мутация входного массива не меняла уже собранные данные.
+*/
+function validateSpans(content, spans) {
+	if (!Array.isArray(spans)) throw new ItdConfigError("spans должен быть массивом");
+	if (content.length === 0 && spans.length > 0) throw new ItdConfigError("Нельзя задать spans без текста: сначала укажите непустой content");
+	return spans.map((span, index) => {
+		if (!span || typeof span !== "object") throw new ItdConfigError(`Некорректный span №${index + 1}: ожидался объект`);
+		const candidate = span;
+		if (typeof candidate.type !== "string" || !Number.isInteger(candidate.offset) || !Number.isInteger(candidate.length) || (candidate.offset ?? -1) < 0 || (candidate.length ?? 0) <= 0 || (candidate.offset ?? 0) + (candidate.length ?? 0) > content.length) throw new ItdConfigError(`Некорректный span №${index + 1}: offset и length должны указывать на непустой фрагмент content`);
+		return { ...candidate };
+	});
+}
+//#endregion
+//#region src/spans/parse.ts
+const HTML_BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"div",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"pre",
+	"section",
+	"ul"
+]);
+const HTML_DROPPED_TAGS = /* @__PURE__ */ new Set([
+	"applet",
+	"canvas",
+	"embed",
+	"iframe",
+	"math",
+	"noscript",
+	"object",
+	"script",
+	"style",
+	"svg",
+	"template"
+]);
+const HTML_ENTITIES = Object.freeze({
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	nbsp: "\xA0",
+	quot: "\""
+});
+function append(output, value) {
+	output.content += value;
+}
+function addSpan(output, start, span) {
+	const length = output.content.length - start;
+	if (length > 0) output.spans.push({
+		...span,
+		offset: start,
+		length
+	});
+}
+function finish(output) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const span of output.spans) {
+		const key = [
+			span.type,
+			span.offset,
+			span.length,
+			span.url ?? "",
+			span.tag ?? "",
+			span.username ?? "",
+			span.id ?? ""
+		].join("\0");
+		if (!unique.has(key)) unique.set(key, span);
+	}
+	return {
+		content: output.content,
+		spans: validateSpans(output.content, [...unique.values()]).sort((left, right) => left.offset - right.offset || right.length - left.length)
+	};
+}
+function allowedProtocols(options) {
+	const values = options.allowedLinkProtocols ?? ["http", "https"];
+	return new Set(values.map((value) => `${value.toLowerCase().replace(/:$/u, "")}:`).filter((value) => value !== ":"));
+}
+function safeLink(value, protocols) {
+	try {
+		const url = new URL(value);
+		return url.hostname !== "" && protocols.has(url.protocol.toLowerCase()) ? value : null;
+	} catch {
+		return null;
+	}
+}
+function isEscaped(value, index) {
+	let slashes = 0;
+	for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) slashes += 1;
+	return slashes % 2 === 1;
+}
+function findClosing(value, marker, from) {
+	let cursor = from;
+	while (cursor < value.length) {
+		const found = value.indexOf(marker, cursor);
+		if (found < 0) return -1;
+		if (!isEscaped(value, found)) return found;
+		cursor = found + marker.length;
+	}
+	return -1;
+}
+function findBracketEnd(value, from, open, close) {
+	let depth = 1;
+	for (let cursor = from; cursor < value.length; cursor += 1) {
+		const character = value[cursor];
+		if (character === "\\") {
+			cursor += 1;
+			continue;
+		}
+		if (character === open) depth += 1;
+		if (character === close) {
+			depth -= 1;
+			if (depth === 0) return cursor;
+		}
+	}
+	return -1;
+}
+function decodeEntities(value) {
+	return value.replace(/&(#(?:x[\da-f]+|\d+)|[a-z][a-z\d]+);/giu, (raw, entity) => {
+		if (entity.startsWith("#x") || entity.startsWith("#X")) {
+			const code = Number.parseInt(entity.slice(2), 16);
+			return Number.isFinite(code) && code <= 1114111 ? String.fromCodePoint(code) : raw;
+		}
+		if (entity.startsWith("#")) {
+			const code = Number.parseInt(entity.slice(1), 10);
+			return Number.isFinite(code) && code <= 1114111 ? String.fromCodePoint(code) : raw;
+		}
+		return HTML_ENTITIES[entity.toLowerCase()] ?? raw;
+	});
+}
+function normalizeCodeSpan(value) {
+	const normalized = value.replace(/\r\n?|\n/gu, " ");
+	if (normalized.length >= 2 && normalized.startsWith(" ") && normalized.endsWith(" ") && !/^ +$/u.test(normalized)) return normalized.slice(1, -1);
+	return normalized;
+}
+function markdownStyle(source, index) {
+	const styles = [
+		{
+			marker: "**",
+			type: SpanType.Bold
+		},
+		{
+			marker: "__",
+			type: SpanType.Bold
+		},
+		{
+			marker: "~~",
+			type: SpanType.Strike
+		},
+		{
+			marker: "||",
+			type: SpanType.Spoiler
+		},
+		{
+			marker: "*",
+			type: SpanType.Italic
+		},
+		{
+			marker: "_",
+			type: SpanType.Italic
+		}
+	];
+	for (const style of styles) {
+		if (!source.startsWith(style.marker, index)) continue;
+		if (style.marker.includes("_")) {
+			const before = source[index - 1] ?? "";
+			const after = source[index + style.marker.length] ?? "";
+			if (/[\p{L}\p{N}]/u.test(before) && /[\p{L}\p{N}]/u.test(after)) continue;
+		}
+		return style;
+	}
+}
+function parseMarkdownInline(source, output, protocols) {
+	let index = 0;
+	while (index < source.length) {
+		const character = source[index] ?? "";
+		if (character === "\\" && index + 1 < source.length) {
+			append(output, source[index + 1] ?? "");
+			index += 2;
+			continue;
+		}
+		if (character === "`") {
+			const run = source.slice(index).match(/^`+/u)?.[0] ?? "`";
+			const close = findClosing(source, run, index + run.length);
+			if (close > index + run.length) {
+				const start = output.content.length;
+				append(output, normalizeCodeSpan(source.slice(index + run.length, close)));
+				addSpan(output, start, { type: SpanType.Monospace });
+				index = close + run.length;
+				continue;
+			}
+		}
+		const image = source.startsWith("![", index);
+		if ((image || character === "[") && !isEscaped(source, index)) {
+			const labelStart = index + (image ? 2 : 1);
+			const labelEnd = findBracketEnd(source, labelStart, "[", "]");
+			if (labelEnd >= 0 && source[labelEnd + 1] === "(") {
+				const destinationEnd = findBracketEnd(source, labelEnd + 2, "(", ")");
+				if (destinationEnd >= 0) {
+					const label = source.slice(labelStart, labelEnd);
+					const destination = source.slice(labelEnd + 2, destinationEnd).trim().replace(/\\([\\)])/gu, "$1");
+					const start = output.content.length;
+					parseMarkdownInline(label, output, protocols);
+					if (!image) {
+						const url = safeLink(destination, protocols);
+						if (url) addSpan(output, start, {
+							type: SpanType.Link,
+							url
+						});
+					}
+					index = destinationEnd + 1;
+					continue;
+				}
+			}
+		}
+		if (source.slice(index, index + 3).toLowerCase() === "<u>") {
+			const close = source.toLowerCase().indexOf("</u>", index + 3);
+			if (close > index + 3) {
+				const start = output.content.length;
+				parseMarkdownInline(source.slice(index + 3, close), output, protocols);
+				addSpan(output, start, { type: SpanType.Underline });
+				index = close + 4;
+				continue;
+			}
+		}
+		if (character === "<") {
+			const close = source.indexOf(">", index + 1);
+			if (close > index + 1) {
+				const candidate = decodeEntities(source.slice(index + 1, close));
+				const url = safeLink(candidate, protocols);
+				if (url) {
+					const start = output.content.length;
+					append(output, candidate);
+					addSpan(output, start, {
+						type: SpanType.Link,
+						url
+					});
+					index = close + 1;
+					continue;
+				}
+			}
+		}
+		const style = markdownStyle(source, index);
+		if (style) {
+			const close = findClosing(source, style.marker, index + style.marker.length);
+			if (close > index + style.marker.length) {
+				const start = output.content.length;
+				parseMarkdownInline(source.slice(index + style.marker.length, close), output, protocols);
+				addSpan(output, start, { type: style.type });
+				index = close + style.marker.length;
+				continue;
+			}
+		}
+		if (character === "&") {
+			const entity = source.slice(index).match(/^&(?:#(?:x[\da-f]+|\d+)|[a-z][a-z\d]+);/iu)?.[0];
+			if (entity) {
+				append(output, decodeEntities(entity));
+				index += entity.length;
+				continue;
+			}
+		}
+		append(output, character);
+		index += 1;
+	}
+}
+function lineEnd(source, from) {
+	const found = source.indexOf("\n", from);
+	return found < 0 ? source.length : found;
+}
+/**
+* Преобразует безопасное подмножество Markdown в текст и wire-spans.
+*
+* Поддерживаются bold, italic, strike, spoiler, inline/fenced code, ссылки, underline
+* через `<u>` и цитаты `>`. Неподдерживаемая и незакрытая разметка остаётся текстом.
+* У изображений сохраняется alt-текст без URL.
+*/
+function parseMarkdown(source, options = {}) {
+	const output = {
+		content: "",
+		spans: []
+	};
+	const protocols = allowedProtocols(options);
+	let position = 0;
+	while (position < source.length) {
+		const end = lineEnd(source, position);
+		const line = source.slice(position, end);
+		const hasNewline = end < source.length;
+		const fence = line.match(/^ {0,3}(`{3,}|~{3,})[^\n]*$/u)?.[1];
+		if (fence) {
+			let closeStart = hasNewline ? end + 1 : source.length;
+			let closeEnd = closeStart;
+			let found = false;
+			while (closeStart < source.length) {
+				closeEnd = lineEnd(source, closeStart);
+				const marker = source.slice(closeStart, closeEnd).match(/^ {0,3}(`{3,}|~{3,})\s*$/u)?.[1];
+				if (marker !== void 0 && marker[0] === fence[0] && marker.length >= fence.length) {
+					found = true;
+					break;
+				}
+				closeStart = closeEnd < source.length ? closeEnd + 1 : source.length;
+			}
+			if (found) {
+				const bodyStart = end + 1;
+				let body = source.slice(bodyStart, closeStart);
+				if (body.endsWith("\n")) body = body.slice(0, -1);
+				const start = output.content.length;
+				append(output, body);
+				addSpan(output, start, { type: SpanType.Monospace });
+				if (closeEnd < source.length) append(output, "\n");
+				position = closeEnd < source.length ? closeEnd + 1 : source.length;
+				continue;
+			}
+		}
+		const quote = line.match(/^ {0,3}> ?(.*)$/u);
+		if (quote) {
+			const start = output.content.length;
+			parseMarkdownInline(quote[1] ?? "", output, protocols);
+			addSpan(output, start, { type: SpanType.Quote });
+		} else parseMarkdownInline(line, output, protocols);
+		if (hasNewline) append(output, "\n");
+		position = hasNewline ? end + 1 : source.length;
+	}
+	return finish(output);
+}
+function readAttribute(source, name) {
+	const pattern = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\\x60]+))`, "iu");
+	const match = source.match(pattern);
+	const value = match?.[1] ?? match?.[2] ?? match?.[3];
+	return value === void 0 ? void 0 : decodeEntities(value);
+}
+function htmlSpan(tag, attributes, protocols) {
+	switch (tag) {
+		case "b":
+		case "strong": return { type: SpanType.Bold };
+		case "em":
+		case "i": return { type: SpanType.Italic };
+		case "u": return { type: SpanType.Underline };
+		case "del":
+		case "s":
+		case "strike": return { type: SpanType.Strike };
+		case "code":
+		case "pre": return { type: SpanType.Monospace };
+		case "blockquote": return { type: SpanType.Quote };
+		case "a": {
+			const href = readAttribute(attributes, "href");
+			const url = href ? safeLink(href, protocols) : null;
+			return url ? {
+				type: SpanType.Link,
+				url
+			} : void 0;
+		}
+		case "span": {
+			const classes = readAttribute(attributes, "class")?.split(/\s+/u) ?? [];
+			if (readAttribute(attributes, "data-spoiler") === "true" || classes.some((value) => value.endsWith("-spoiler"))) return { type: SpanType.Spoiler };
+			if (classes.some((value) => value.endsWith("-quote"))) return { type: SpanType.Quote };
+			return;
+		}
+		default: return;
+	}
+}
+function ensureBlockBreak(output) {
+	if (output.content !== "" && !output.content.endsWith("\n")) append(output, "\n");
+}
+function findHtmlTagEnd(source, from) {
+	let quote;
+	for (let index = from; index < source.length; index += 1) {
+		const character = source[index];
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === ">") return index;
+	}
+	return -1;
+}
+/**
+* Преобразует ограниченный HTML в обычный текст и wire-spans.
+*
+* Разрешены только семантические теги форматирования. Атрибуты событий игнорируются,
+* содержимое `script`, `style`, `iframe`, `object`, SVG и подобных активных элементов
+* удаляется. Опасный `href` сохраняет текст ссылки, но не создаёт span.
+*/
+function parseHtml(source, options = {}) {
+	const output = {
+		content: "",
+		spans: []
+	};
+	const protocols = allowedProtocols(options);
+	const stack = [];
+	let position = 0;
+	const closeTag = (tag) => {
+		for (let index = stack.length - 1; index >= 0; index -= 1) {
+			const open = stack[index];
+			if (open?.tag !== tag) continue;
+			stack.splice(index, 1);
+			addSpan(output, open.start, open.span);
+			return;
+		}
+	};
+	while (position < source.length) {
+		if (source.startsWith("<!--", position)) {
+			const end = source.indexOf("-->", position + 4);
+			position = end < 0 ? source.length : end + 3;
+			continue;
+		}
+		if (source[position] === "<") {
+			const end = findHtmlTagEnd(source, position + 1);
+			if (end >= 0) {
+				const parsed = source.slice(position, end + 1).match(/^<\s*(\/?)\s*([a-z][\w-]*)([\s\S]*?)\/?\s*>$/iu);
+				if (parsed) {
+					const closing = parsed[1] === "/";
+					const tag = (parsed[2] ?? "").toLowerCase();
+					const attributes = parsed[3] ?? "";
+					if (!closing && HTML_DROPPED_TAGS.has(tag)) {
+						const closingPattern = new RegExp(`<\\s*\\/\\s*${tag}\\s*>`, "igu");
+						closingPattern.lastIndex = end + 1;
+						const match = closingPattern.exec(source);
+						position = match ? match.index + match[0].length : source.length;
+						continue;
+					}
+					if (tag === "br" && !closing) {
+						append(output, "\n");
+						position = end + 1;
+						continue;
+					}
+					if (tag === "img" && !closing) {
+						append(output, readAttribute(attributes, "alt") ?? "");
+						position = end + 1;
+						continue;
+					}
+					if (closing) {
+						closeTag(tag);
+						if (HTML_BLOCK_TAGS.has(tag)) ensureBlockBreak(output);
+					} else {
+						if (HTML_BLOCK_TAGS.has(tag)) ensureBlockBreak(output);
+						const span = htmlSpan(tag, attributes, protocols);
+						if (span) stack.push({
+							tag,
+							start: output.content.length,
+							span
+						});
+					}
+					position = end + 1;
+					continue;
+				}
+			}
+		}
+		const next = source.indexOf("<", position + 1);
+		const end = next < 0 ? source.length : next;
+		append(output, decodeEntities(source.slice(position, end)));
+		position = end;
+	}
+	while (stack.length > 0) {
+		const open = stack.pop();
+		if (open) addSpan(output, open.start, open.span);
+	}
+	while (output.content.endsWith("\n")) output.content = output.content.slice(0, -1);
+	return finish(output);
+}
+//#endregion
+//#region src/builders/markup.ts
+function validateMarkup(value) {
+	if (!value || typeof value.content !== "string" || !Array.isArray(value.spans)) throw new ItdConfigError("Разметка должна содержать строку content и массив spans");
+	return {
+		content: value.content,
+		spans: validateSpans(value.content, value.spans).sort((left, right) => left.offset - right.offset || right.length - left.length)
+	};
+}
+function entityName(value, prefix, label) {
+	const name = value.startsWith(prefix) ? value.slice(prefix.length) : value;
+	if (name === "" || /\s/u.test(name)) throw new ItdConfigError(`${label} должен быть непустым и не содержать пробелов`);
+	return name;
+}
+/**
+* Неизменяемый билдер текста с разметкой.
+*
+* Каждый метод дописывает фрагмент и сам считает `offset` и `length` в единицах UTF-16 —
+* именно такие индексы использует JavaScript-редактор сайта.
+*/
+var MarkupBuilder = class MarkupBuilder {
+	/** @internal */
+	[BUILDER] = true;
+	#content;
+	#spans;
+	/** @internal Создавайте билдер функцией {@link markup}. */
+	constructor(content, spans) {
+		this.#content = content;
+		this.#spans = spans;
+	}
+	/** Дописывает обычный текст без разметки. */
+	text(value) {
+		return new MarkupBuilder(this.#content + value, this.#spans);
+	}
+	/** Дописывает переводы строк. */
+	newline(count = 1) {
+		if (!Number.isInteger(count) || count < 0) throw new ItdConfigError("Количество переводов строк должно быть целым неотрицательным");
+		return this.text("\n".repeat(count));
+	}
+	/** @internal Добавляет готовый фрагмент и сдвигает его spans к текущему концу текста. */
+	#formatted(value, outerSpans) {
+		const fragment = typeof value === "string" ? {
+			content: value,
+			spans: []
+		} : resolveMarkup(value);
+		if (fragment.content.length === 0) throw new ItdConfigError("Размечаемый фрагмент не может быть пустым");
+		const offset = this.#content.length;
+		const shifted = fragment.spans.map((span) => ({
+			...span,
+			offset: span.offset + offset
+		}));
+		const outer = outerSpans.map((span) => ({
+			...span,
+			offset,
+			length: fragment.content.length
+		}));
+		return new MarkupBuilder(this.#content + fragment.content, [
+			...this.#spans,
+			...shifted,
+			...outer
+		]);
+	}
+	/**
+	* Дописывает фрагмент с произвольным типом разметки.
+	*
+	* Вложенный билдер позволяет форматировать часть фрагмента дополнительным стилем.
+	* Для нескольких стилей на всём фрагменте используйте {@link styled}.
+	*/
+	span(value, span) {
+		return this.#formatted(value, [span]);
+	}
+	/**
+	* Дописывает фрагмент с несколькими стилями на одном диапазоне.
+	*
+	* Для `link`, которому нужен `url`, используйте {@link link}; произвольные spans с
+	* метаданными можно объединять через вложенные вызовы {@link span}.
+	*/
+	styled(value, ...types) {
+		if (types.length === 0) return this.#formatted(value, []);
+		return this.#formatted(value, types.map((type) => ({ type })));
+	}
+	/** Дописывает `#хэштег` и сохраняет имя без решётки в `tag`. */
+	hashtag(tag) {
+		const name = entityName(tag, "#", "Хэштег");
+		return this.span(`#${name}`, {
+			type: SpanType.Hashtag,
+			tag: name
+		});
+	}
+	/** Дописывает `@username` и сохраняет имя пользователя в `username`. */
+	mention(username) {
+		const name = entityName(username, "@", "Упоминание");
+		return this.span(`@${name}`, {
+			type: SpanType.Mention,
+			username: name
+		});
+	}
+	/**
+	* Дописывает ссылку.
+	*
+	* Для строки адрес по умолчанию становится и текстом ссылки. Вложенному форматированному
+	* фрагменту URL нужно передать явно.
+	*/
+	link(content, url) {
+		const resolvedUrl = url ?? (typeof content === "string" ? content : void 0);
+		if (resolvedUrl === void 0) throw new ItdConfigError("Для форматированного текста ссылки нужно явно передать URL");
+		return this.span(content, {
+			type: SpanType.Link,
+			url: resolvedUrl
+		});
+	}
+	bold(content) {
+		return this.span(content, { type: SpanType.Bold });
+	}
+	italic(content) {
+		return this.span(content, { type: SpanType.Italic });
+	}
+	underline(content) {
+		return this.span(content, { type: SpanType.Underline });
+	}
+	strike(content) {
+		return this.span(content, { type: SpanType.Strike });
+	}
+	spoiler(content) {
+		return this.span(content, { type: SpanType.Spoiler });
+	}
+	monospace(content) {
+		return this.span(content, { type: SpanType.Monospace });
+	}
+	quote(content) {
+		return this.span(content, { type: SpanType.Quote });
+	}
+	build() {
+		return validateMarkup({
+			content: this.#content,
+			spans: this.#spans
+		});
+	}
+	toJSON() {
+		return this.build();
+	}
+};
+/** Начинает сборку текста с автоматически вычисляемыми смещениями. */
+function markup(content = "") {
+	return new MarkupBuilder(content, []);
+}
+/** Приводит любую форму разметки к тексту и массиву spans. */
+function resolveMarkup(input) {
+	return resolveInput(input, () => markup(), validateMarkup);
+}
+function trimUrlEnd(value) {
+	let result = value;
+	const pairs = [
+		["(", ")"],
+		["[", "]"],
+		["{", "}"]
+	];
+	let changed;
+	do {
+		const before = result;
+		while (/[.,!?;:…'"»”]$/u.test(result)) result = result.slice(0, -1);
+		for (const [open, close] of pairs) while (result.endsWith(close) && result.split(close).length > result.split(open).length) result = result.slice(0, -1);
+		changed = result !== before;
+	} while (changed);
+	return result;
+}
+function overlaps(span, start, end) {
+	return span.offset < end && start < span.offset + span.length;
+}
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "";
+	} catch {
+		return false;
+	}
+}
+function previousCodePoint(text, index) {
+	if (index <= 0) return "";
+	const last = text.charCodeAt(index - 1);
+	if (last >= 56320 && last <= 57343 && index >= 2) {
+		const first = text.charCodeAt(index - 2);
+		if (first >= 55296 && first <= 56319) return text.slice(index - 2, index);
+	}
+	return text[index - 1] ?? "";
+}
+/**
+* Находит в тексте те сущности, которые сайт получает после серверного разбора:
+* HTTP(S)-ссылки, `#хэштеги` и `@упоминания`.
+*
+* Смещения выражены в UTF-16 code units, поэтому совпадают с `String#slice`,
+* `substring`, DOM Selection и wire-форматом сайта даже при наличии эмодзи.
+*/
+function autoSpans(text, options = {}) {
+	const includeLinks = options.links ?? true;
+	const includeHashtags = options.hashtags ?? true;
+	const includeMentions = options.mentions ?? true;
+	const spans = [];
+	const links = [];
+	for (const match of text.matchAll(/https?:\/\/[^\s<>"'`]+/giu)) {
+		const raw = trimUrlEnd(match[0]);
+		if (raw.length === 0 || match.index === void 0 || !isHttpUrl(raw)) continue;
+		links.push({
+			type: SpanType.Link,
+			offset: match.index,
+			length: raw.length,
+			url: raw
+		});
+	}
+	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 (match.index === void 0) continue;
+		const offset = match.index;
+		const previous = previousCodePoint(text, offset);
+		if (/[\p{L}\p{M}\p{N}_#@.]/u.test(previous)) continue;
+		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, "");
+		if (hashtag !== void 0 && includeHashtags) spans.push({
+			type: SpanType.Hashtag,
+			offset,
+			length: match[0].length,
+			tag: hashtag
+		});
+		else if (username !== void 0 && includeMentions) spans.push({
+			type: SpanType.Mention,
+			offset,
+			length: username.length + 1,
+			username
+		});
+	}
+	return spans.sort((left, right) => left.offset - right.offset || right.length - left.length);
+}
+//#endregion
+//#region src/builders/poll.ts
+/** Минимальное число вариантов ответа. */
+const MIN_OPTIONS = 2;
+/** Ограничения опроса — те же, что действуют в интерфейсе итд.com. */
+const MAX_OPTIONS = 10;
+const MAX_QUESTION_LENGTH = 200;
+const MAX_OPTION_LENGTH = 100;
+/**
+* Проверяет данные опроса.
+*
+* Применяется и к билдеру, и к обычному объекту — правила одни и те же.
+*
+* @throws {ItdConfigError} если вопрос пуст, вариантов меньше двух или есть дубли
+*/
+function validatePoll(input) {
+	const question = input?.question;
+	if (typeof question !== "string" || question.trim() === "") throw new ItdConfigError("Опрос требует непустого вопроса");
+	if (question.trim().length > MAX_QUESTION_LENGTH) throw new ItdConfigError(`Вопрос длиннее ${MAX_QUESTION_LENGTH} символов (передано ${question.trim().length})`);
+	const texts = (Array.isArray(input.options) ? input.options : []).map((option, index) => {
+		const text = typeof option?.text === "string" ? option.text.trim() : "";
+		if (text === "") throw new ItdConfigError(`Вариант ответа №${index + 1} пуст — у каждого должен быть текст`);
+		if (text.length > MAX_OPTION_LENGTH) throw new ItdConfigError(`Вариант ответа №${index + 1} длиннее ${MAX_OPTION_LENGTH} символов (передано ${text.length})`);
+		return text;
+	});
+	if (texts.length < MIN_OPTIONS) throw new ItdConfigError(`Опрос требует минимум ${MIN_OPTIONS} варианта, передано: ${texts.length}`);
+	if (texts.length > MAX_OPTIONS) throw new ItdConfigError(`Опрос допускает не больше ${MAX_OPTIONS} вариантов, передано: ${texts.length}`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const text of texts) {
+		if (seen.has(text)) throw new ItdConfigError(`Вариант «${text}» повторяется — варианты должны различаться`);
+		seen.add(text);
+	}
+	return {
+		question: question.trim(),
+		options: texts.map((text) => ({ text })),
+		multipleChoice: input.multipleChoice ?? false
+	};
+}
+/**
+* Билдер опроса.
+*
+* Неизменяемый: каждый вызов возвращает новый экземпляр, поэтому заготовку можно
+* переиспользовать, не боясь её испортить. Создаётся функцией {@link poll}.
+*/
+var PollBuilder = class PollBuilder {
+	/** @internal */
+	[BUILDER] = true;
+	#state;
+	/** @internal Создавайте билдер функцией {@link poll}. */
+	constructor(state) {
+		this.#state = state;
+	}
+	/** Задаёт вопрос. */
+	question(text) {
+		return new PollBuilder({
+			...this.#state,
+			question: text
+		});
+	}
+	/** Добавляет один вариант ответа. */
+	option(text) {
+		return new PollBuilder({
+			...this.#state,
+			options: [...this.#state.options, { text }]
+		});
+	}
+	/**
+	* Добавляет несколько вариантов сразу.
+	*
+	* @example
+	* ```ts
+	* poll('ну как?').options('да', 'нет', 'не знаю');
+	* ```
+	*/
+	options(...texts) {
+		return new PollBuilder({
+			...this.#state,
+			options: [...this.#state.options, ...texts.map((text) => ({ text }))]
+		});
+	}
+	/** Разрешает выбор нескольких вариантов. */
+	multipleChoice(enabled = true) {
+		return new PollBuilder({
+			...this.#state,
+			multipleChoice: enabled
+		});
+	}
+	build() {
+		return validatePoll(this.#state);
+	}
+	toJSON() {
+		return this.build();
+	}
+};
+/**
+* Начинает сборку опроса.
+*
+* @param question вопрос; можно задать позже методом {@link PollBuilder.question}
+*
+* @example
+* ```ts
+* import { poll } from 'itd-api';
+*
+* const q = poll('Какой язык лучше?')
+*   .options('TypeScript', 'JavaScript')
+*   .multipleChoice();
+*
+* await itd.posts.create({ content: 'голосуем', poll: q });
+* ```
+*/
+function poll(question = "") {
+	return new PollBuilder({
+		question,
+		options: []
+	});
+}
+/** Приводит любую форму входа к готовым данным опроса. */
+function resolvePoll(input) {
+	return resolveInput(input, () => poll(), validatePoll);
+}
+//#endregion
+//#region src/builders/post.ts
+/** UUID любой версии. */
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const BUILD_UPDATE = Symbol.for("itd.postBuilder.update");
+/**
+* Проверяет и нормализует данные поста.
+*
+* Отдельного внимания заслуживает `wallRecipientId`: API принимает там **только UUID**,
+* а имя пользователя молча приводит к ошибке на сервере. Проверка здесь превращает
+* это в понятное сообщение до отправки запроса.
+*
+* @throws {ItdConfigError} если пост пуст или получатель стены задан именем пользователя
+*/
+function validatePost(input) {
+	const content = typeof input?.content === "string" ? input.content : "";
+	const attachmentIds = input?.attachmentIds ?? [];
+	const files = input?.files ?? [];
+	const hasContent = content.trim() !== "";
+	const hasAttachments = attachmentIds.length > 0 || files.length > 0;
+	const hasPoll = Boolean(input?.poll);
+	if (!hasContent && !hasAttachments && !hasPoll) throw new ItdConfigError("Пост пуст: нужен текст, вложение или опрос");
+	const wallRecipientId = input.wallRecipientId;
+	if (wallRecipientId !== void 0 && wallRecipientId !== null) {
+		if (!UUID_PATTERN.test(wallRecipientId)) throw new ItdConfigError(`wallRecipientId должен быть UUID, а не именем пользователя (получено: «${wallRecipientId}»). Идентификатор можно взять из профиля: (await itd.users.get(username)).id`);
+	}
+	const { poll: inputPoll, ...data } = input;
+	return {
+		...data,
+		...input.spans !== void 0 ? { spans: validateSpans(content, input.spans) } : {},
+		...inputPoll !== void 0 ? { poll: resolvePoll(inputPoll) } : {}
+	};
+}
+/**
+* Билдер поста.
+*
+* Неизменяемый: каждый вызов возвращает новый экземпляр, поэтому заготовку можно
+* переиспользовать. Создаётся функцией {@link post}.
+*
+* @example Заготовка для нескольких постов
+* ```ts
+* const onWall = post().onWall(userId);
+*
+* await itd.posts.create(onWall.content('первый'));
+* await itd.posts.create(onWall.content('второй'));  // заготовка не испорчена
+* ```
+*/
+var PostBuilder = class PostBuilder {
+	/** @internal */
+	[BUILDER] = true;
+	#state;
+	/** @internal Создавайте билдер функцией {@link post}. */
+	constructor(state) {
+		this.#state = state;
+	}
+	/**
+	* Задаёт текст поста, заменяя прежний вместе с его разметкой.
+	*
+	* Spans привязаны к конкретному тексту, поэтому после замены их нужно задать заново
+	* через {@link spans}, {@link markup} или {@link autoSpans}.
+	*/
+	content(text) {
+		const state = {
+			...this.#state,
+			content: text,
+			contentSet: true
+		};
+		delete state.spans;
+		return new PostBuilder(state);
+	}
+	/** Дописывает текст к уже заданному. */
+	append(text) {
+		const separator = this.#state.content === "" ? "" : "\n";
+		return new PostBuilder({
+			...this.#state,
+			content: this.#state.content + separator + text,
+			contentSet: true
+		});
+	}
+	/**
+	* Задаёт готовую разметку текста. Смещения проверяются при {@link build}.
+	*
+	* Для автоматического поиска сущностей есть {@link autoSpans}, а для вычисления смещений
+	* при сборке текста — {@link markup}.
+	*/
+	spans(spans) {
+		return new PostBuilder({
+			...this.#state,
+			spans
+		});
+	}
+	/**
+	* Заменяет текст и разметку результатом {@link MarkupBuilder}.
+	*
+	* @example
+	* ```ts
+	* post().markup((m) => m.text('смотрите ').hashtag('котики').text(' от ').mention('nowkie'));
+	* ```
+	*/
+	markup(input) {
+		const result = resolveMarkup(input);
+		return new PostBuilder({
+			...this.#state,
+			content: result.content,
+			contentSet: true,
+			spans: result.spans
+		});
+	}
+	/** Заменяет текст и spans результатом безопасного разбора Markdown. */
+	markdown(source, options = {}) {
+		return this.markup(parseMarkdown(source, options));
+	}
+	/** Заменяет текст и spans результатом безопасного разбора ограниченного HTML. */
+	html(source, options = {}) {
+		return this.markup(parseHtml(source, options));
+	}
+	/**
+	* Находит HTTP(S)-ссылки, хэштеги и упоминания в уже заданном тексте.
+	*
+	* Ручные стили сохраняются. Повторный вызов не дублирует уже найденные сущности.
+	*/
+	autoSpans(options = {}) {
+		const current = this.#state.spans ?? [];
+		const entityTypes = /* @__PURE__ */ new Set([
+			SpanType.Hashtag,
+			SpanType.Mention,
+			SpanType.Link
+		]);
+		const detected = autoSpans(this.#state.content, options).filter((candidate) => {
+			return !current.some((span) => entityTypes.has(span.type) && span.offset < candidate.offset + candidate.length && candidate.offset < span.offset + span.length);
+		});
+		return new PostBuilder({
+			...this.#state,
+			spans: [...current, ...detected].sort((left, right) => left.offset - right.offset || right.length - left.length)
+		});
+	}
+	/**
+	* Публикует пост на стене другого пользователя.
+	*
+	* @param userId **UUID** пользователя; имя пользователя не подойдёт
+	*/
+	onWall(userId) {
+		return new PostBuilder({
+			...this.#state,
+			wallRecipientId: userId
+		});
+	}
+	/**
+	* Прикладывает файл — он будет загружен перед публикацией.
+	*
+	* Порядок вызовов сохраняется в порядке вложений.
+	*/
+	attach(file) {
+		return new PostBuilder({
+			...this.#state,
+			files: [...this.#state.files, file]
+		});
+	}
+	/** Прикладывает уже загруженное вложение по его идентификатору. */
+	attachId(attachmentId) {
+		return new PostBuilder({
+			...this.#state,
+			attachmentIds: [...this.#state.attachmentIds, attachmentId]
+		});
+	}
+	/**
+	* Добавляет опрос.
+	*
+	* Принимает объект, {@link PollBuilder} или функцию-настройщик.
+	*
+	* @example
+	* ```ts
+	* post('голосуем').poll((q) => q.question('ну как?').options('да', 'нет'));
+	* ```
+	*/
+	poll(input) {
+		return new PostBuilder({
+			...this.#state,
+			poll: resolvePoll(input)
+		});
+	}
+	#input(includeEmptyContent = false) {
+		const { content, contentSet: _contentSet, attachmentIds, files, ...rest } = this.#state;
+		return {
+			...rest,
+			...content !== "" || includeEmptyContent ? { content } : {},
+			...attachmentIds.length > 0 ? { attachmentIds } : {},
+			...files.length > 0 ? { files } : {}
+		};
+	}
+	build() {
+		return validatePost(this.#input());
+	}
+	/** @internal Собирает данные по правилам `posts.update`, не применяя правила создания. */
+	[BUILD_UPDATE]() {
+		return validatePostUpdate(this.#input(this.#state.contentSet));
+	}
+	toJSON() {
+		return this.build();
+	}
+};
+/**
+* Начинает сборку поста.
+*
+* @param content текст; можно задать позже методом {@link PostBuilder.content}
+*
+* @example
+* ```ts
+* import { post } from 'itd-api';
+*
+* await itd.posts.create(
+*   post('смотрите что нашёл')
+*     .attach({ url: 'https://example.com/photo.jpg' })
+*     .poll((q) => q.question('нравится?').options('да', 'нет')),
+* );
+* ```
+*/
+function post(content) {
+	return new PostBuilder({
+		content: content ?? "",
+		contentSet: content !== void 0,
+		attachmentIds: [],
+		files: []
+	});
+}
+/** Приводит любую форму входа к готовым данным поста. */
+function resolvePost(input) {
+	const resolved = typeof input === "function" ? input(post()) : input;
+	return isBuilder(resolved) ? validatePost(resolved.build()) : validatePost(resolved);
+}
+function validatePostUpdate(input) {
+	if (!input || typeof input !== "object") throw new ItdConfigError("Для обновления поста нужен объект с явно заданным content");
+	const unsupported = [
+		"wallRecipientId",
+		"attachmentIds",
+		"files",
+		"poll"
+	].filter((key) => input[key] !== void 0);
+	if (unsupported.length > 0) throw new ItdConfigError(`posts.update изменяет только content и spans; не поддерживаются: ${unsupported.join(", ")}`);
+	if (input.content === void 0) throw new ItdConfigError("posts.update требует явно заданный content; обновление одних spans могло бы стереть текст поста");
+	if (typeof input.content !== "string") throw new ItdConfigError("content обновляемого поста должен быть строкой");
+	if (input.spans !== void 0 && !Array.isArray(input.spans)) throw new ItdConfigError("spans обновляемого поста должен быть массивом");
+	return {
+		content: input.content,
+		...input.spans !== void 0 ? { spans: validateSpans(input.content, input.spans) } : {}
+	};
+}
+/** Приводит вход `posts.update` к поддерживаемым данным поста. */
+function resolvePostUpdate(input) {
+	if (typeof input === "function") {
+		const result = input(post());
+		return isBuilder(result) ? result[BUILD_UPDATE]() : validatePostUpdate(result);
+	}
+	return isBuilder(input) ? input[BUILD_UPDATE]() : validatePostUpdate(input);
+}
+//#endregion
+//#region src/resources/posts.ts
+/** Курсорная позиция из параметров: если курсор задан — с него, иначе с начала. */
+function cursorStart(params) {
+	return params.cursor ? { cursor: params.cursor } : {};
+}
+/**
+* Посты: лента, публикация, реакции, репосты, комментарии.
+*
+* Доступна как `itd.posts`.
+*/
+var PostsResource = class extends BaseResource {
+	#uploadFiles;
+	/** Лента: `/api/posts`, курсорная пагинация. */
+	#feed = this.paginated({
+		operationId: "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/${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/${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/${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) {
+		super(http);
+		this.#uploadFiles = deps.uploadFiles;
+	}
+	/**
+	* Загружает страницу ленты.
+	*
+	* @example
+	* ```ts
+	* const page = await itd.posts.list({ tab: FeedTab.Following, limit: 20 });
+	* const next = await itd.posts.list({ tab: FeedTab.Following, cursor: page.nextCursor ?? undefined });
+	* ```
+	*/
+	list(params = {}, options = {}) {
+		return this.#feed.list(params, options);
+	}
+	/**
+	* Перебирает ленту, сама подставляя курсоры.
+	*
+	* @example
+	* ```ts
+	* for await (const post of itd.posts.iterate({ tab: 'following' })) {
+	*   console.log(post.author.username, post.content);
+	* }
+	* ```
+	*/
+	iterate(params = {}, options = {}) {
+		return this.#feed.iterate(params, options);
+	}
+	/**
+	* Публикует пост.
+	*
+	* Принимает обычный объект, {@link PostBuilder} или функцию-настройщик. Файлы из поля
+	* `files` загружаются автоматически, порядок вложений сохраняется.
+	*
+	* @example
+	* ```ts
+	* await itd.posts.create({ content: 'привет' });
+	* await itd.posts.create((p) => p.content('привет').attach({ url: 'https://example.com/photo.jpg' }));
+	* ```
+	*/
+	async create(input, options = {}) {
+		const data = resolvePost(input);
+		const attachmentIds = await this.#collectAttachments(data, options);
+		return this.http.operation("posts.create", {
+			path: "/api/posts",
+			body: {
+				content: data.content ?? "",
+				...data.spans ? { spans: data.spans } : {},
+				...data.wallRecipientId ? { wallRecipientId: data.wallRecipientId } : {},
+				...attachmentIds.length > 0 ? { attachmentIds } : {},
+				...data.poll ? { poll: data.poll } : {}
+			},
+			...options
+		});
+	}
+	/**
+	* Загружает один пост вместе с топовыми комментариями.
+	*
+	* В отличие от списков, здесь у поста заполнено поле `comments`.
+	*/
+	get(postId, options = {}) {
+		return this.http.operation("posts.get", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+			...options
+		});
+	}
+	/**
+	* Редактирует текст и разметку поста.
+	*
+	* Как и {@link create}, принимает объект, готовый {@link PostBuilder} или
+	* функцию-настройщик. Поля создания поста, которые update endpoint не поддерживает
+	* (вложения, опрос и стена), отвергаются до запроса.
+	*/
+	update(postId, input, options = {}) {
+		const data = resolvePostUpdate(input);
+		return this.http.operation("posts.update", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+			body: {
+				content: data.content,
+				...data.spans ? { spans: data.spans } : {}
+			},
+			...options
+		});
+	}
+	/** Удаляет пост. Восстановить его можно через {@link restore}. */
+	remove(postId, options = {}) {
+		return this.http.operation("posts.remove", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+			...options
+		});
+	}
+	/** Восстанавливает удалённый пост. */
+	restore(postId, options = {}) {
+		return this.http.operation("posts.restore", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/restore`,
+			...options
+		});
+	}
+	/** Ставит реакцию на пост. */
+	like(postId, options = {}) {
+		return this.http.operation("posts.like", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
+			...options
+		});
+	}
+	/** Убирает реакцию с поста. */
+	unlike(postId, options = {}) {
+		return this.http.operation("posts.unlike", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
+			...options
+		});
+	}
+	/**
+	* Делает репост с необязательным комментарием.
+	*
+	* Вложения к репосту не поддерживаются: сервер их игнорирует, поэтому параметров
+	* для файлов здесь нет.
+	*/
+	repost(postId, content = "", options = {}) {
+		return this.http.operation("posts.repost", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
+			body: { content },
+			...options
+		});
+	}
+	/** Отменяет репост. */
+	unrepost(postId, options = {}) {
+		return this.http.operation("posts.unrepost", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
+			...options
+		});
+	}
+	/** Закрепляет пост в профиле. */
+	pin(postId, options = {}) {
+		return this.http.operation("posts.pin", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
+			...options
+		});
+	}
+	/** Открепляет пост. */
+	unpin(postId, options = {}) {
+		return this.http.operation("posts.unpin", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
+			...options
+		});
+	}
+	/**
+	* Голосует в опросе.
+	*
+	* @param optionIds выбранные варианты; несколько допустимы только при `multipleChoice`
+	*/
+	vote(postId, optionIds, options = {}) {
+		return this.http.operation("posts.vote", {
+			path: `/api/posts/${encodePathSegment(postId, "postId")}/poll/vote`,
+			body: { optionIds },
+			...options
+		});
+	}
+	/** Запрашивает счётчики сразу для нескольких постов. */
+	async stats(ids, options = {}) {
+		const body = await this.http.operation("posts.stats", {
+			path: "/api/posts/stats",
+			body: { ids },
+			...options
+		});
+		return pickArray(body, "posts");
+	}
+	/**
+	* Загружает страницу стены пользователя.
+	*
+	* Это **не только его собственные посты**: сюда попадают и записи, которые другие
+	* оставили на его стене — у них `author` чужой, а `wallRecipient` указывает на владельца
+	* стены. Поэтому число записей обычно больше, чем `postsCount` из профиля; чтобы
+	* получить только авторские посты, отфильтруйте по `post.author.id`.
+	*
+	* Принимает и UUID, и имя пользователя.
+	*/
+	byUser(user, params = {}, options = {}) {
+		return this.#wall.list({
+			...params,
+			user
+		}, options);
+	}
+	/** Перебирает стену пользователя. Что именно в неё входит — см. {@link byUser}. */
+	iterateByUser(user, params = {}, options = {}) {
+		return this.#wall.iterate({
+			...params,
+			user
+		}, options);
+	}
+	/** Загружает страницу постов, которые пользователь отметил реакцией. */
+	likedByUser(user, params = {}, options = {}) {
+		return this.#liked.list({
+			...params,
+			user
+		}, options);
+	}
+	/** Перебирает посты, которые пользователь отметил реакцией. */
+	iterateLikedByUser(user, params = {}, options = {}) {
+		return this.#liked.iterate({
+			...params,
+			user
+		}, options);
+	}
+	/**
+	* Загружает страницу комментариев к посту.
+	*
+	* У этого эндпоинта курсор и признак продолжения лежат рядом со списком, а не внутри
+	* объекта `pagination`, как у остальных, — разница скрыта внутри.
+	*/
+	comments(postId, params = {}, options = {}) {
+		return this.#comments.list({
+			...params,
+			postId
+		}, options);
+	}
+	/** Перебирает комментарии к посту. */
+	iterateComments(postId, params = {}, options = {}) {
+		return this.#comments.iterate({
+			...params,
+			postId
+		}, options);
+	}
+	/**
+	* Комментирует пост.
+	*
+	* @example
+	* ```ts
+	* await itd.posts.comment(postId, 'согласен');
+	* await itd.posts.comment(postId, (c) => c.content('смотри').attach(blob));
+	* ```
+	*/
+	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/${encodePathSegment(postId, "postId")}/comments`,
+			body: {
+				content: data.content ?? "",
+				attachmentIds
+			},
+			...options
+		});
+	}
+	/**
+	* Отправляет голосовой комментарий.
+	*
+	* Текста у такого комментария нет: сервер ждёт пустой `content` и одно аудиовложение
+	* в формате `audio/ogg`.
+	*
+	* @example
+	* ```ts
+	* import { fromPath } from 'itd-api/node';
+	*
+	* await itd.posts.voiceComment(postId, fromPath('./answer.ogg'));
+	* ```
+	*/
+	voiceComment(postId, audio, options = {}) {
+		return this.comment(postId, {
+			content: "",
+			files: [audio]
+		}, options);
+	}
+	/** Загружает файлы из входных данных и объединяет их с уже готовыми идентификаторами. */
+	async #collectAttachments(data, options) {
+		const existing = data.attachmentIds ?? [];
+		const files = data.files ?? [];
+		if (files.length === 0) return existing;
+		const uploaded = await this.#uploadFiles(files, options);
+		return [...existing, ...uploaded];
+	}
+};
+//#endregion
+//#region src/builders/report.ts
+const REASONS = new Set(Object.values(ReportReason));
+const TARGET_TYPES = new Set(Object.values(ReportTargetType));
+/**
+* Проверяет данные жалобы.
+*
+* @throws {ItdConfigError} если объект жалобы или причина заданы неверно
+*/
+function validateReport(input) {
+	if (!input?.targetId || typeof input.targetId !== "string") throw new ItdConfigError("Жалоба требует идентификатор объекта (targetId)");
+	if (!TARGET_TYPES.has(input.targetType)) throw new ItdConfigError(`targetType должен быть одним из ${[...TARGET_TYPES].join(", ")}, получено: ${String(input.targetType)}`);
+	if (!REASONS.has(input.reason)) throw new ItdConfigError(`Неизвестная причина жалобы «${String(input.reason)}». Допустимые: ${[...REASONS].join(", ")}`);
+	return input;
+}
+/**
+* Билдер жалобы.
+*
+* Точка входа задаёт объект жалобы и его тип одновременно, поэтому рассогласовать
+* `targetType` и `targetId` невозможно. Создаётся объектом {@link report}.
+*/
+var ReportBuilder = class ReportBuilder {
+	/** @internal */
+	[BUILDER] = true;
+	#state;
+	/** @internal Создавайте билдер через {@link report}. */
+	constructor(state) {
+		this.#state = state;
+	}
+	/** Указывает причину жалобы. */
+	reason(reason) {
+		return new ReportBuilder({
+			...this.#state,
+			reason
+		});
+	}
+	/** Добавляет пояснение в свободной форме. */
+	description(text) {
+		return new ReportBuilder({
+			...this.#state,
+			description: text
+		});
+	}
+	build() {
+		return validateReport(this.#state);
+	}
+	toJSON() {
+		return this.build();
+	}
+};
+function start(targetType, targetId) {
+	return new ReportBuilder({
+		targetType,
+		targetId
+	});
+}
+/**
+* Начинает сборку жалобы.
+*
+* Тип объекта выбирается точкой входа, так что указать идентификатор комментария
+* с типом «пост» нельзя в принципе.
+*
+* @example
+* ```ts
+* import { report, ReportReason } from 'itd-api';
+*
+* await itd.reports.create(report.post(postId).reason(ReportReason.Spam));
+* await itd.reports.create(report.user(userId).reason('fraud').description('пишет в личку'));
+* ```
+*/
+const report = Object.freeze({
+	/** Жалоба на пост. */
+	post: (postId) => start(ReportTargetType.Post, postId),
+	/** Жалоба на комментарий. */
+	comment: (commentId) => start(ReportTargetType.Comment, commentId),
+	/** Жалоба на пользователя. */
+	user: (userId) => start(ReportTargetType.User, userId)
+});
+/** Приводит любую форму входа к готовым данным жалобы. */
+function resolveReport(input) {
+	return resolveInput(input, () => new ReportBuilder({}), validateReport);
+}
+//#endregion
+//#region src/resources/reports.ts
+/**
+* Жалобы на контент и пользователей.
+*
+* Доступна как `itd.reports`.
+*/
+var ReportsResource = class extends BaseResource {
+	/**
+	* Отправляет жалобу.
+	*
+	* Повторная жалоба на тот же объект отклоняется сервером с сообщением
+	* «Вы уже отправляли жалобу на этот контент».
+	*
+	* @example
+	* ```ts
+	* await itd.reports.create(report.post(postId).reason('spam'));
+	* await itd.reports.create({ targetType: 'user', targetId, reason: 'fraud' });
+	* ```
+	*/
+	create(input, options = {}) {
+		const data = resolveReport(input);
+		return this.http.operation("reports.create", {
+			path: "/api/reports",
+			body: data,
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/resources/search.ts
+/**
+* Глобальный поиск.
+*
+* Доступна как `itd.search`.
+*/
+var SearchResource = class extends BaseResource {
+	/**
+	* Ищет пользователей и хэштеги одним запросом.
+	*
+	* @example
+	* ```ts
+	* const { users, hashtags } = await itd.search.all('арт');
+	* ```
+	*/
+	async all(query, options = {}) {
+		const body = await this.http.operation("search.all", {
+			path: "/api/search",
+			query: { q: query },
+			...options
+		});
+		return {
+			users: pickArray(body, "users"),
+			hashtags: pickArray(body, "hashtags")
+		};
+	}
+};
+//#endregion
+//#region src/resources/subscription.ts
+/**
+* Подписка и способы оплаты.
+*
+* Доступна как `itd.subscription`.
+*/
+var SubscriptionResource = class extends BaseResource {
+	/** Загружает состояние подписки и её цену. */
+	status(options = {}) {
+		return this.http.operation("subscription.status", {
+			path: "/api/v1/subscription/",
+			...options
+		});
+	}
+	/**
+	* Запускает оплату подписки.
+	*
+	* Форма ответа в документации API не описана, поэтому тип результата не уточняется.
+	*/
+	pay(options = {}) {
+		return this.http.operation("subscription.pay", {
+			path: "/api/v1/subscription/pay",
+			...options
+		});
+	}
+	/** Включает или отключает автопродление. */
+	setAutoRenewal(enabled, options = {}) {
+		return this.http.operation("subscription.setAutoRenewal", {
+			path: "/api/v1/subscription/auto-renewal",
+			body: { enabled },
+			...options
+		});
+	}
+	/** Запускает привязку карты. */
+	bindCard(options = {}) {
+		return this.http.operation("subscription.bindCard", {
+			path: "/api/v1/subscription/bind-card",
+			...options
+		});
+	}
+	/** Загружает список способов оплаты. Пустой массив, если карт нет. */
+	async methods(options = {}) {
+		const body = await this.http.operation("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/${encodePathSegment(methodId, "methodId")}/default`,
+			...options
+		});
+	}
+	/** Удаляет способ оплаты. */
+	removeMethod(methodId, options = {}) {
+		return this.http.operation("subscription.removeMethod", {
+			path: `/api/v1/subscription/methods/${encodePathSegment(methodId, "methodId")}`,
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/resources/telemetry.ts
+const DEFAULT_BATCH_SIZE = 50;
+const SYSTEM_CLOCK = Object.freeze({ now: () => Date.now() });
+function assertNonEmpty(value, name) {
+	if (value.trim().length === 0) throw new ItdConfigError(`${name} должен быть непустой строкой`);
+}
+function assertFinite(value, name) {
+	if (!Number.isFinite(value)) throw new ItdConfigError(`${name} должен быть конечным числом`);
+}
+function assertNonNegative(value, name) {
+	assertFinite(value, name);
+	if (value < 0) throw new ItdConfigError(`${name} должен быть неотрицательным числом`);
+}
+function validateDwell(entry) {
+	assertNonEmpty(entry.vs, "vs");
+	assertFinite(entry.enterAt, "enterAt");
+	assertFinite(entry.exitAt, "exitAt");
+	if (entry.exitAt < entry.enterAt) throw new ItdConfigError("exitAt не может быть раньше enterAt");
+	if (entry.durationMs !== void 0) assertNonNegative(entry.durationMs, "durationMs");
+	return { ...entry };
+}
+function validateInteraction(entry) {
+	assertNonEmpty(entry.vs, "vs");
+	assertNonEmpty(entry.postId, "postId");
+	if (entry.mediaIndex !== void 0) {
+		assertNonNegative(entry.mediaIndex, "mediaIndex");
+		if (!Number.isInteger(entry.mediaIndex)) throw new ItdConfigError("mediaIndex должен быть целым числом");
+	}
+	if (entry.positionMs !== void 0) assertNonNegative(entry.positionMs, "positionMs");
+	if (entry.durationMs !== void 0) assertNonNegative(entry.durationMs, "durationMs");
+	return { ...entry };
+}
+function photoOpenEntry(input) {
+	return validateInteraction({
+		type: InteractionType.PhotoOpen,
+		...input
+	});
+}
+function videoProgressEntry(input) {
+	return validateInteraction({
+		type: InteractionType.VideoProgress,
+		...input
+	});
+}
+var ViewTrackerImpl = class {
+	enteredAt;
+	#clock;
+	#input;
+	#submit;
+	#result;
+	constructor(input, clock, submit) {
+		assertNonEmpty(input.vs, "vs");
+		this.enteredAt = clock.now();
+		assertFinite(this.enteredAt, "clock.now()");
+		this.#input = { ...input };
+		this.#clock = clock;
+		this.#submit = submit;
+	}
+	get finished() {
+		return this.#result !== void 0;
+	}
+	finish(reason) {
+		if (this.#result) return this.#result;
+		try {
+			const exitAt = this.#clock.now();
+			assertFinite(exitAt, "clock.now()");
+			if (exitAt < this.enteredAt) throw new ItdConfigError("часы не могут вернуться назад во время измерения просмотра");
+			this.#result = Promise.resolve(this.#submit({
+				...this.#input,
+				enterAt: this.enteredAt,
+				exitAt,
+				reason
+			}));
+		} catch (error) {
+			this.#result = Promise.reject(error);
+		}
+		return this.#result;
+	}
+};
+var TelemetryBatchImpl = class {
+	#sendDwell;
+	#sendInteraction;
+	#telemetryOptions;
+	#requestOptions;
+	#clock;
+	#maxBatchSize;
+	#onClose;
+	#dwell = [];
+	#interactions = [];
+	#state = "open";
+	#flushPromise;
+	#closePromise;
+	#disposeCleanup = false;
+	constructor(sendDwell, sendInteraction, options, requestOptions, onClose) {
+		const { maxBatchSize = DEFAULT_BATCH_SIZE, clock = SYSTEM_CLOCK, ...telemetryOptions } = options;
+		if (!Number.isInteger(maxBatchSize) || maxBatchSize < 1) throw new ItdConfigError("maxBatchSize должен быть целым числом от 1");
+		this.#sendDwell = sendDwell;
+		this.#sendInteraction = sendInteraction;
+		this.#telemetryOptions = telemetryOptions;
+		this.#requestOptions = requestOptions;
+		this.#clock = clock;
+		this.#maxBatchSize = maxBatchSize;
+		this.#onClose = onClose;
+	}
+	get pendingDwell() {
+		return this.#dwell.length;
+	}
+	get pendingInteractions() {
+		return this.#interactions.length;
+	}
+	get closed() {
+		return this.#state === "closed";
+	}
+	dwell(entry) {
+		this.#assertOpen();
+		const entries = Array.isArray(entry) ? entry : [entry];
+		this.#dwell.push(...entries.map(validateDwell));
+		return this;
+	}
+	interaction(entry) {
+		this.#assertOpen();
+		const entries = Array.isArray(entry) ? entry : [entry];
+		this.#interactions.push(...entries.map(validateInteraction));
+		return this;
+	}
+	photoOpen(input) {
+		return this.interaction(photoOpenEntry(input));
+	}
+	videoProgress(input) {
+		return this.interaction(videoProgressEntry(input));
+	}
+	startView(input) {
+		this.#assertOpen();
+		return new ViewTrackerImpl(input, this.#clock, (entry) => {
+			this.dwell(entry);
+		});
+	}
+	flush(options = {}) {
+		if (this.#state === "closed") return Promise.resolve();
+		if (this.#flushPromise) return this.#flushPromise;
+		const tracked = this.#flushAll({
+			...this.#requestOptions,
+			...options
+		}).finally(() => {
+			if (this.#flushPromise === tracked) this.#flushPromise = void 0;
+		});
+		this.#flushPromise = tracked;
+		return tracked;
+	}
+	close() {
+		return this.#close(false);
+	}
+	/** Внутренняя финализация после перехода клиента в terminal state. */
+	closeForDispose() {
+		this.prepareForDispose();
+		return this.#close(true);
+	}
+	/** Переключает ещё не начатые части flush на terminal-cleanup канал. */
+	prepareForDispose() {
+		this.#disposeCleanup = true;
+	}
+	#close(disposeCleanup) {
+		this.#disposeCleanup ||= disposeCleanup;
+		if (this.#state === "closed") return Promise.resolve();
+		if (this.#closePromise) return this.#closePromise;
+		this.#state = "closing";
+		const tracked = this.flush().then(() => {
+			this.#state = "closed";
+			this.#onClose();
+		}).catch((error) => {
+			this.#state = "open";
+			throw error;
+		}).finally(() => {
+			if (this.#closePromise === tracked) this.#closePromise = void 0;
+		});
+		this.#closePromise = tracked;
+		return tracked;
+	}
+	async #flushAll(options) {
+		while (this.#dwell.length > 0) {
+			const chunk = this.#dwell.splice(0, this.#maxBatchSize);
+			try {
+				await this.#sendDwell(chunk, this.#telemetryOptions, options, this.#disposeCleanup);
+			} catch (error) {
+				this.#dwell.unshift(...chunk);
+				throw error;
+			}
+		}
+		while (this.#interactions.length > 0) {
+			const chunk = this.#interactions.splice(0, this.#maxBatchSize);
+			try {
+				await this.#sendInteraction(chunk, this.#telemetryOptions, options, this.#disposeCleanup);
+			} catch (error) {
+				this.#interactions.unshift(...chunk);
+				throw error;
+			}
+		}
+	}
+	#assertOpen() {
+		if (this.#state !== "open") throw new ItdConfigError("накопитель телеметрии уже закрывается или закрыт");
+	}
+};
+const TELEMETRY_DISPOSE_CLOSERS = /* @__PURE__ */ new WeakMap();
+const TELEMETRY_DISPOSE_PREPARERS = /* @__PURE__ */ new WeakMap();
+/**
+* Телеметрия просмотров и взаимодействий.
+*
+* Ничего не отправляет автоматически: каждый запрос, tracker или накопитель создаётся
+* явным вызовом пользователя. Доступна как `itd.telemetry`.
+*/
+var TelemetryResource = class extends BaseResource {
+	#sessionId;
+	#batches = /* @__PURE__ */ new Set();
+	constructor(http) {
+		super(http);
+		TELEMETRY_DISPOSE_PREPARERS.set(this, () => {
+			for (const batch of this.#batches) batch.prepareForDispose();
+		});
+		TELEMETRY_DISPOSE_CLOSERS.set(this, () => this.#close(true));
+	}
+	/** Идентификатор сессии телеметрии, общий для всех событий этого ресурса. */
+	get sessionId() {
+		this.#sessionId ??= createDeviceId();
+		return this.#sessionId;
+	}
+	/** Отправляет события просмотра постов (`POST /api/v1/i`). */
+	dwell(entries, telemetryOptions = {}, requestOptions = {}) {
+		const validated = entries.map(validateDwell);
+		return this.#sendDwell(validated, telemetryOptions, requestOptions, false);
+	}
+	#sendDwell(entries, telemetryOptions, requestOptions, disposeCleanup) {
+		const options = {
+			path: "/api/v1/i",
+			body: {
+				sid: telemetryOptions.sid ?? this.sessionId,
+				e: entries.map((entry) => ({
+					md: entry.durationMs ?? entry.exitAt - entry.enterAt,
+					et: entry.enterAt,
+					xt: entry.exitAt,
+					r: entry.reason,
+					v: entry.vs,
+					...entry.sourceContext !== void 0 ? { sc: entry.sourceContext } : {},
+					...entry.source !== void 0 ? { s: entry.source } : {},
+					...entry.repeat ? { b: 1 } : {}
+				}))
+			},
+			...requestOptions
+		};
+		return disposeCleanup ? this.http.cleanupOperation("telemetry.dwell", options) : this.http.operation("telemetry.dwell", options);
+	}
+	/** Отправляет события взаимодействия с контентом (`POST /api/v1/x`). */
+	interaction(entries, telemetryOptions = {}, requestOptions = {}) {
+		const validated = entries.map(validateInteraction);
+		return this.#sendInteraction(validated, telemetryOptions, requestOptions, false);
+	}
+	#sendInteraction(entries, telemetryOptions, requestOptions, disposeCleanup) {
+		const options = {
+			path: "/api/v1/x",
+			body: {
+				sid: telemetryOptions.sid ?? this.sessionId,
+				e: entries.map((entry) => ({
+					t: entry.type,
+					v: entry.vs,
+					ai: entry.postId,
+					...entry.mediaIndex !== void 0 ? { mi: entry.mediaIndex } : {},
+					...entry.source !== void 0 ? { s: entry.source } : {},
+					...entry.positionMs !== void 0 ? { pm: Math.round(entry.positionMs) } : {},
+					...entry.durationMs !== void 0 ? { dm: Math.round(entry.durationMs) } : {}
+				}))
+			},
+			...requestOptions
+		};
+		return disposeCleanup ? this.http.cleanupOperation("telemetry.interaction", options) : this.http.operation("telemetry.interaction", options);
+	}
+	/** Начинает измерять время просмотра и отправляет результат после `finish()`. */
+	startView(input, options = {}, requestOptions = {}) {
+		const { clock = SYSTEM_CLOCK, ...telemetryOptions } = options;
+		return new ViewTrackerImpl(input, clock, async (entry) => {
+			await this.dwell([entry], telemetryOptions, requestOptions);
+		});
+	}
+	/** Отправляет событие открытия фотографии. */
+	photoOpen(input, telemetryOptions = {}, requestOptions = {}) {
+		return this.interaction([photoOpenEntry(input)], telemetryOptions, requestOptions);
+	}
+	/** Отправляет событие прогресса просмотра видео. */
+	videoProgress(input, telemetryOptions = {}, requestOptions = {}) {
+		return this.interaction([videoProgressEntry(input)], telemetryOptions, requestOptions);
+	}
+	/**
+	* Создаёт накопитель с явными `flush()` и `close()`.
+	*
+	* Создание и добавление записей не выполняют сетевых запросов.
+	*/
+	batch(options = {}, requestOptions = {}) {
+		let batch;
+		batch = new TelemetryBatchImpl((entries, telemetry, request, cleanup) => this.#sendDwell(entries, telemetry, request, cleanup), (entries, telemetry, request, cleanup) => this.#sendInteraction(entries, telemetry, request, cleanup), options, requestOptions, () => {
+			this.#batches.delete(batch);
+		});
+		this.#batches.add(batch);
+		return batch;
+	}
+	/** Закрывает все созданные накопители, отправляя оставшиеся записи. */
+	async close() {
+		return this.#close(false);
+	}
+	async #close(disposeCleanup) {
+		const errors = (await Promise.allSettled([...this.#batches].map((batch) => disposeCleanup ? batch.closeForDispose() : batch.close()))).filter((result) => result.status === "rejected").map((result) => result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось отправить накопленную телеметрию");
+	}
+};
+/** Помечает открытые накопители для terminal cleanup до первой асинхронной границы. @internal */
+function prepareTelemetryForDispose(resource) {
+	if (resource) TELEMETRY_DISPOSE_PREPARERS.get(resource)?.();
+}
+/** Финализирует созданные накопители после перехода клиента в terminal state. @internal */
+function closeTelemetryForDispose(resource) {
+	return resource ? TELEMETRY_DISPOSE_CLOSERS.get(resource)?.() ?? Promise.resolve() : Promise.resolve();
+}
+//#endregion
+//#region src/resources/users.ts
+/**
+* Пользователи: профили, подписки, блокировки, приватность.
+*
+* Доступна как `itd.users`.
+*/
+var UsersResource = class extends BaseResource {
+	#uploadFile;
+	constructor(http, deps) {
+		super(http);
+		this.#uploadFile = deps.uploadFile;
+	}
+	/**
+	* Списки пользователей: подписчики, подписки, заблокированные.
+	*
+	* Путь приходит в параметрах — так один описатель обслуживает все три эндпоинта. Имена
+	* полей перечислены с запасом: списки приходят под `users`, но альтернативное имя ничего
+	* не стоит и спасает, если эндпоинт назовёт список по-своему. `page` уходит в запрос, хотя
+	* сервер его сейчас не читает (см. {@link followers}): когда починят — заработает само.
+	*/
+	#userList = this.paginated({
+		operationId: (p) => p.operationId,
+		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", {
+			path: "/api/users/me",
+			...options
+		});
+	}
+	/** Обновляет свой профиль. Передавайте только изменяемые поля. */
+	updateMe(input, options = {}) {
+		return this.http.operation("users.updateMe", {
+			path: "/api/users/me",
+			body: input,
+			...options
+		});
+	}
+	/**
+	* Загружает изображение и устанавливает его баннером профиля.
+	*
+	* Для установки используется идентификатор, полученный от `/api/files/upload`.
+	* Если файл уже загружен, используйте {@link updateMe}: `{ bannerId: file.id }`.
+	*
+	* @example
+	* ```ts
+	* await itd.users.setBanner(file, { filename: 'banner.webp' });
+	* ```
+	*/
+	async setBanner(file, uploadOptions = {}, requestOptions = {}) {
+		const uploaded = await this.#uploadFile(file, uploadOptions, requestOptions);
+		return this.updateMe({ bannerId: uploaded.id }, requestOptions);
+	}
+	/** Удаляет баннер профиля, устанавливая `bannerId` в `null`. */
+	removeBanner(options = {}) {
+		return this.updateMe({ bannerId: null }, options);
+	}
+	/** Деактивирует аккаунт. Вернуть его можно через {@link restore}. */
+	deactivate(options = {}) {
+		return this.http.operation("users.deactivate", {
+			path: "/api/users/me",
+			...options
+		});
+	}
+	/** Восстанавливает деактивированный аккаунт. */
+	restore(options = {}) {
+		return this.http.operation("users.restore", {
+			path: "/api/users/me/restore",
+			...options
+		});
+	}
+	/** Создаёт профиль после регистрации. */
+	createProfile(input, options = {}) {
+		return this.http.operation("users.createProfile", {
+			path: "/api/users/profile",
+			body: input,
+			...options
+		});
+	}
+	/**
+	* Загружает профиль пользователя.
+	*
+	* @param user UUID **или** имя пользователя — подходит и то, и другое
+	*
+	* @example
+	* ```ts
+	* const profile = await itd.users.get('nowkie');
+	* await itd.posts.create({ content: 'привет', wallRecipientId: profile.id });
+	* ```
+	*/
+	get(user, options = {}) {
+		return this.http.operation("users.get", {
+			path: `/api/users/${encodePathSegment(user, "user")}`,
+			...options
+		});
+	}
+	/** Проверяет, свободно ли имя пользователя. */
+	async checkUsername(username, options = {}) {
+		const body = await this.http.operation("users.checkUsername", {
+			path: "/api/users/check-username",
+			query: { username },
+			...options
+		});
+		return pickBoolean(body, "available");
+	}
+	/** Ищет пользователей по строке запроса. */
+	async search(query, params = {}, options = {}) {
+		const body = await this.http.operation("users.search", {
+			path: "/api/users/search",
+			query: {
+				q: query,
+				limit: params.limit
+			},
+			...options
+		});
+		return pickArray(body, "users");
+	}
+	/** Загружает рекомендации, на кого подписаться. */
+	async whoToFollow(options = {}) {
+		const body = await this.http.operation("users.whoToFollow", {
+			path: "/api/users/suggestions/who-to-follow",
+			...options
+		});
+		return pickArray(body, "users");
+	}
+	/** Загружает рейтинг кланов. */
+	async topClans(options = {}) {
+		const body = await this.http.operation("users.topClans", {
+			path: "/api/users/stats/top-clans",
+			...options
+		});
+		return pickArray(body, "clans");
+	}
+	/**
+	* Подписывается на пользователя.
+	*
+	* У закрытого профиля вместо подписки отправляется заявка — это видно по полю `status`.
+	*/
+	follow(user, options = {}) {
+		return this.http.operation("users.follow", {
+			path: `/api/users/${encodePathSegment(user, "user")}/follow`,
+			body: {},
+			...options
+		});
+	}
+	/** Отписывается от пользователя. */
+	unfollow(user, options = {}) {
+		return this.http.operation("users.unfollow", {
+			path: `/api/users/${encodePathSegment(user, "user")}/follow`,
+			...options
+		});
+	}
+	/**
+	* Загружает подписчиков пользователя.
+	*
+	* ⚠️ **Сервер этот список не листает.** Возвращаются первые 20 записей и только они:
+	* параметр `page` игнорируется (любая страница отдаёт те же записи и `pagination.page: 1`),
+	* `limit` больше 20 молча уменьшается, а `hasMore` всегда `false`. Последнее честно —
+	* получить продолжение нечем.
+	*
+	* Числу `total` доверять тоже не стоит: оно расходится с `followersCount` из профиля —
+	* на проверенных аккаунтах занижено примерно на 1–4%.
+	*/
+	followers(user, params = {}, options = {}) {
+		return this.#userPage("users.followers", `/api/users/${encodePathSegment(user, "user")}/followers`, params, options);
+	}
+	/**
+	* Перебирает подписчиков.
+	*
+	* ⚠️ Перебор закончится после первых 20 записей: сервер список не листает —
+	* см. {@link followers}. Метод оставлен на случай, если пагинацию починят.
+	*/
+	iterateFollowers(user, params = {}, options = {}) {
+		return this.#userPaginator("users.followers", `/api/users/${encodePathSegment(user, "user")}/followers`, params, options);
+	}
+	/** Загружает подписки пользователя. Ограничения те же, что у {@link followers}. */
+	following(user, params = {}, options = {}) {
+		return this.#userPage("users.following", `/api/users/${encodePathSegment(user, "user")}/following`, params, options);
+	}
+	/** Перебирает подписки. Закончится после первых 20 записей — см. {@link followers}. */
+	iterateFollowing(user, params = {}, options = {}) {
+		return this.#userPaginator("users.following", `/api/users/${encodePathSegment(user, "user")}/following`, params, options);
+	}
+	/**
+	* Проверяет, подписаны ли вы, сразу для нескольких пользователей.
+	*
+	* @returns объект «идентификатор пользователя → подписаны ли вы»
+	*
+	* @example
+	* ```ts
+	* const statuses = await itd.users.followStatus([userA, userB]);
+	* // { 'b89dee4f-…': true, '35ea3059-…': false }
+	* ```
+	*/
+	followStatus(userIds, options = {}) {
+		return this.http.operation("users.followStatus", {
+			path: "/api/users/follow-status",
+			body: { userIds },
+			...options
+		});
+	}
+	/** Блокирует пользователя. */
+	block(user, options = {}) {
+		return this.http.operation("users.block", {
+			path: `/api/users/${encodePathSegment(user, "user")}/block`,
+			body: {},
+			...options
+		});
+	}
+	/** Снимает блокировку. */
+	unblock(user, options = {}) {
+		return this.http.operation("users.unblock", {
+			path: `/api/users/${encodePathSegment(user, "user")}/block`,
+			...options
+		});
+	}
+	/** Загружает заблокированных пользователей. Ограничения те же, что у {@link followers}. */
+	blocked(params = {}, options = {}) {
+		return this.#userPage("users.blocked", "/api/users/me/blocked", params, options);
+	}
+	/** Перебирает заблокированных. Закончится после первых 20 записей — см. {@link followers}. */
+	iterateBlocked(params = {}, options = {}) {
+		return this.#userPaginator("users.blocked", "/api/users/me/blocked", params, options);
+	}
+	/** Загружает настройки приватности. */
+	getPrivacy(options = {}) {
+		return this.http.operation("users.getPrivacy", {
+			path: "/api/users/me/privacy",
+			...options
+		});
+	}
+	/** Обновляет настройки приватности. Передавайте только изменяемые поля. */
+	updatePrivacy(input, options = {}) {
+		return this.http.operation("users.updatePrivacy", {
+			path: "/api/users/me/privacy",
+			body: input,
+			...options
+		});
+	}
+	/**
+	* Загружает значки профиля и выбранный из них.
+	*
+	* `activePin` — строка-идентификатор, а не объект.
+	*/
+	async pins(options = {}) {
+		const body = await this.http.operation("users.pins", {
+			path: "/api/users/me/pins",
+			...options
+		});
+		return {
+			pins: pickArray(body, "pins"),
+			activePin: pickString(body, "activePin") ?? null
+		};
+	}
+	/** Выбирает активный значок профиля. */
+	setPin(slug, options = {}) {
+		return this.http.operation("users.setPin", {
+			path: "/api/users/me/pin",
+			body: { slug },
+			...options
+		});
+	}
+	/** Снимает активный значок. */
+	removePin(options = {}) {
+		return this.http.operation("users.removePin", {
+			path: "/api/users/me/pin",
+			...options
+		});
+	}
+	#userPage(operationId, path, params, options) {
+		return this.#userList.list({
+			...params,
+			operationId,
+			path
+		}, options);
+	}
+	#userPaginator(operationId, path, params, options) {
+		return this.#userList.iterate({
+			...params,
+			operationId,
+			path
+		}, options);
+	}
+};
+//#endregion
+//#region src/resources/verification.ts
+/**
+* Верификация профиля.
+*
+* Доступна как `itd.verification`.
+*/
+var VerificationResource = class extends BaseResource {
+	/** Загружает статус заявки. Значение `none` означает, что заявка не подавалась. */
+	status(options = {}) {
+		return this.http.operation("verification.status", {
+			path: "/api/verification/status",
+			...options
+		});
+	}
+	/** Подаёт заявку на верификацию с видео. */
+	submit(videoUrl, options = {}) {
+		return this.http.operation("verification.submit", {
+			path: "/api/verification/submit",
+			body: { videoUrl },
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/rest/resources.ts
+/**
+* Собирает набор ресурсов, создавая каждый при первом обращении.
+*
+* Ленивость существенна: клиенту редко нужны все двенадцать разом, а закрытие не должно
+* поднимать накопитель телеметрии только ради того, чтобы его тут же закрыть.
+*
+* Набор общий для полного клиента и минимального REST-клиента — иначе список ресурсов
+* и их зависимости разъезжались бы по двум фасадам.
+*/
+function createResources(deps) {
+	let users;
+	let posts;
+	let comments;
+	let files;
+	let notifications;
+	let hashtags;
+	let search;
+	let reports;
+	let verification;
+	let subscription;
+	let platform;
+	let telemetry;
+	const bag = {
+		get users() {
+			users ??= new UsersResource(deps.http, { uploadFile });
+			return users;
+		},
+		get posts() {
+			posts ??= new PostsResource(deps.http, { uploadFiles });
+			return posts;
+		},
+		get comments() {
+			comments ??= new CommentsResource(deps.http, { uploadFiles });
+			return comments;
+		},
+		get files() {
+			files ??= new FilesResource(deps.http, { fetch: deps.fetch });
+			return files;
+		},
+		get notifications() {
+			notifications ??= new NotificationsResource(deps.http);
+			return notifications;
+		},
+		get hashtags() {
+			hashtags ??= new HashtagsResource(deps.http);
+			return hashtags;
+		},
+		get search() {
+			search ??= new SearchResource(deps.http);
+			return search;
+		},
+		get reports() {
+			reports ??= new ReportsResource(deps.http);
+			return reports;
+		},
+		get verification() {
+			verification ??= new VerificationResource(deps.http);
+			return verification;
+		},
+		get subscription() {
+			subscription ??= new SubscriptionResource(deps.http);
+			return subscription;
+		},
+		get platform() {
+			platform ??= new PlatformResource(deps.http, deps.status);
+			return platform;
+		},
+		get telemetry() {
+			telemetry ??= new TelemetryResource(deps.http);
+			return telemetry;
+		},
+		closeTelemetry: (forDispose) => forDispose ? closeTelemetryForDispose(telemetry) : telemetry?.close() ?? Promise.resolve(),
+		prepareTelemetryClose: () => prepareTelemetryForDispose(telemetry)
+	};
+	const uploadFile = (file, uploadOptions, requestOptions) => bag.files.upload(file, uploadOptions ?? {}, requestOptions ?? {});
+	const uploadFiles = (input, requestOptions) => bag.files.uploadMany(input, {}, requestOptions ?? {});
+	return bag;
+}
+//#endregion
+//#region src/core/attachments/factories.ts
+function fromUrl(url, options = {}) {
+	if (resolveFileStreamOptions(options, 104857600).mode === FileTransferMode.Stream) return { open: (context) => openUrlFile(url, options, context) };
+	return { load: (context) => downloadFile(url, options, context) };
+}
+/**
+* Создаёт повторяемый пользовательский поток.
+*
+* Фабрика вызывается заново для каждой попытки; возвращать один и тот же поток нельзя.
+*/
+function fromStream(factory, options = {}) {
+	const resolved = resolveFileStreamOptions({
+		...options,
+		mode: FileTransferMode.Stream
+	}, void 0);
+	optionalBytes(options.size, "size");
+	return { open: async (context) => {
+		let opened;
+		try {
+			opened = await factory(context);
+		} catch (error) {
+			if (error instanceof ItdFileError || error instanceof ItdConfigError || context.signal?.aborted) throw error;
+			throw new ItdFileError("не удалось открыть поток вложения", {
+				reason: ItdFileErrorReason.Read,
+				retryable: true,
+				cause: error
+			});
+		}
+		const content = isReadableByteStream(opened) ? { stream: opened } : opened;
+		if (!content || !isReadableByteStream(content.stream)) throw new ItdConfigError("fromStream должен вернуть ReadableStream или { stream }");
+		const size = options.size ?? content.size;
+		optionalBytes(size, "size");
+		if (resolved.maxBytes !== void 0 && size !== void 0 && size > resolved.maxBytes) {
+			await content.close?.();
+			throw fileTooLarge(void 0, resolved.maxBytes, size);
+		}
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType);
+		return {
+			stream: boundedFileStream(content.stream, {
+				...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+				streamBufferBytes: resolved.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {},
+				retryableRead: true
+			}),
+			...options.filename ?? content.filename ? { filename: options.filename ?? content.filename } : {},
+			...contentType ? { contentType } : {},
+			...size !== void 0 ? { size } : {},
+			...content.close ? { close: content.close } : {}
+		};
+	} };
+}
+//#endregion
+//#region src/models/guards.ts
+/**
+* Свой ли это профиль.
+*
+* @example
+* ```ts
+* if (isMyProfile(profile)) console.log(profile.subscription.isActive);
+* ```
+*/
+function isMyProfile(profile) {
+	return "subscription" in profile;
+}
+//#endregion
+//#region src/models/status-helpers.ts
+const STATUS_WINDOW_DAYS = 90;
+/**
+* Разворачивает историю сервиса в массив на 90 суток.
+* Сутки без данных становятся `null`.
+*
+* @returns массив, где индекс — сколько суток назад: `[0]` — сегодня
+*
+* @example
+* ```ts
+* const status = await itd.platform.status();
+* const days = statusDays(status.services[0]);
+*
+* days[0]?.uptime;                              // доступность за сегодня
+* days.filter((day) => day === null).length;    // за сколько суток данных нет
+* ```
+*/
+function statusDays(service) {
+	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
+}
+//#endregion
+//#region src/spans/render.ts
+/** Формат результата {@link renderSpans}. */
+const SpanRenderFormat = Object.freeze({
+	Html: "html",
+	Markdown: "markdown",
+	Ansi: "ansi"
+});
+function normalizedSpans(content, spans) {
+	const result = [];
+	for (const span of spans ?? []) {
+		if (!span || !Number.isFinite(span.offset) || !Number.isFinite(span.length) || span.length <= 0) continue;
+		const start = Math.max(0, Math.trunc(span.offset));
+		const end = Math.min(content.length, Math.trunc(span.offset + span.length));
+		if (start < end && start < content.length) result.push({
+			span,
+			start,
+			end
+		});
+	}
+	return result;
+}
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function safeHttpUrl(value) {
+	if (!value) return null;
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+	} catch {
+		return null;
+	}
+}
+function safeNavigationUrl(value) {
+	if (!value) return null;
+	try {
+		const url = new URL(value, "https://itd.invalid");
+		return url.protocol === "http:" || url.protocol === "https:" ? value : null;
+	} catch {
+		return null;
+	}
+}
+function entityValue(span, content, kind) {
+	const offset = Number.isFinite(span.offset) ? Math.max(0, Math.trunc(span.offset)) : 0;
+	const end = Number.isFinite(span.length) ? Math.min(content.length, offset + Math.max(0, Math.trunc(span.length))) : offset;
+	const text = content.slice(offset, end);
+	if (kind === "mention") return span.username ?? span.tag ?? text.replace(/^@/u, "");
+	return span.tag ?? text.replace(/^#/u, "");
+}
+function mentionUrl(username, options) {
+	return options.mentionUrl ? options.mentionUrl(username) : `/@${encodeURIComponent(username)}`;
+}
+function hashtagUrl(tag, options) {
+	return options.hashtagUrl ? options.hashtagUrl(tag) : `/hashtag/${encodeURIComponent(tag)}`;
+}
+function classAttribute(name, options) {
+	const prefix = options.classPrefix === void 0 ? "itd" : options.classPrefix;
+	return prefix ? ` class="${escapeHtml(`${prefix}-${name}`)}"` : "";
+}
+function has(active, type) {
+	return active.some((span) => span.type === type);
+}
+function last(active, type) {
+	for (let index = active.length - 1; index >= 0; index -= 1) {
+		const span = active[index];
+		if (span?.type === type) return span;
+	}
+}
+function renderHtmlSegment(text, active, content, options) {
+	let rendered = escapeHtml(text).replace(/\n/g, "<br>");
+	if (has(active, SpanType.Bold)) rendered = `<strong>${rendered}</strong>`;
+	if (has(active, SpanType.Italic)) rendered = `<em>${rendered}</em>`;
+	if (has(active, SpanType.Underline)) rendered = `<u>${rendered}</u>`;
+	if (has(active, SpanType.Strike)) rendered = `<s>${rendered}</s>`;
+	if (has(active, SpanType.Monospace)) rendered = `<code>${rendered}</code>`;
+	if (has(active, SpanType.Quote)) rendered = `<span${classAttribute("quote", options)}>${rendered}</span>`;
+	if (has(active, SpanType.Spoiler)) rendered = `<span${classAttribute("spoiler", options)} data-spoiler="true">${rendered}</span>`;
+	const url = safeHttpUrl(last(active, SpanType.Link)?.url);
+	if (url) rendered = `<a href="${escapeHtml(url)}" rel="noopener noreferrer">${rendered}</a>`;
+	const mention = last(active, SpanType.Mention);
+	if (mention) {
+		const href = safeNavigationUrl(mentionUrl(entityValue(mention, content, "mention"), options));
+		if (href) rendered = `<a href="${escapeHtml(href)}"${classAttribute("mention", options)}>${rendered}</a>`;
+	}
+	const hashtag = last(active, SpanType.Hashtag);
+	if (hashtag) {
+		const href = safeNavigationUrl(hashtagUrl(entityValue(hashtag, content, "hashtag"), options));
+		if (href) rendered = `<a href="${escapeHtml(href)}"${classAttribute("hashtag", options)}>${rendered}</a>`;
+	}
+	return rendered;
+}
+function escapeMarkdown(value, startsAtLineStart) {
+	return value.replace(/([\\`*_[\]<>~|&])/g, "\\$1").split("\n").map((line, index) => {
+		if (index === 0 && !startsAtLineStart) return line;
+		return line.replace(/^ {0,3}(?=#{1,6}(?:[ \t]|$))/u, "$&\\").replace(/^ {0,3}(?=[+-][ \t])/u, "$&\\").replace(/^(\s{0,3}\d{1,9})([.)])(?=[ \t])/u, "$1\\$2").replace(/^(\s{0,3})(?=-(?:[ \t]*-){2,}[ \t]*$)/u, "$1\\");
+	}).join("\n");
+}
+function markdownCodeSpan(text) {
+	const normalized = text.replace(/\r\n?|\n/g, " ");
+	const longestRun = Math.max(0, ...Array.from(normalized.matchAll(/`+/g), (match) => match[0].length));
+	const fence = "`".repeat(longestRun + 1);
+	const allSpaces = /^ +$/u.test(normalized);
+	return `${fence}${normalized.startsWith("`") || normalized.endsWith("`") || !allSpaces && normalized.startsWith(" ") && normalized.endsWith(" ") ? ` ${normalized} ` : normalized}${fence}`;
+}
+function markdownUrl(value) {
+	return value.replace(/([\\)])/g, "\\$1");
+}
+function renderMarkdownSegment(segment, content, options) {
+	const { text, active } = segment;
+	const startsAtLineStart = segment.start === 0 || content[segment.start - 1] === "\n";
+	let rendered = has(active, SpanType.Monospace) ? markdownCodeSpan(text) : escapeMarkdown(text, startsAtLineStart);
+	if (has(active, SpanType.Bold)) rendered = `**${rendered}**`;
+	if (has(active, SpanType.Italic)) rendered = `*${rendered}*`;
+	if (has(active, SpanType.Underline)) rendered = `<u>${rendered}</u>`;
+	if (has(active, SpanType.Strike)) rendered = `~~${rendered}~~`;
+	if (has(active, SpanType.Spoiler)) rendered = `||${rendered}||`;
+	const url = safeHttpUrl(last(active, SpanType.Link)?.url);
+	if (url) rendered = `[${rendered}](${markdownUrl(url)})`;
+	const mention = last(active, SpanType.Mention);
+	if (mention) {
+		const href = safeNavigationUrl(mentionUrl(entityValue(mention, content, "mention"), options));
+		if (href) rendered = `[${rendered}](${markdownUrl(href)})`;
+	}
+	const hashtag = last(active, SpanType.Hashtag);
+	if (hashtag) {
+		const href = safeNavigationUrl(hashtagUrl(entityValue(hashtag, content, "hashtag"), options));
+		if (href) rendered = `[${rendered}](${markdownUrl(href)})`;
+	}
+	return rendered;
+}
+function renderMarkdown(segments, content, options) {
+	const groups = [];
+	for (const segment of segments) {
+		const quoted = has(segment.active, SpanType.Quote);
+		const rendered = renderMarkdownSegment(segment, content, options);
+		const previous = groups[groups.length - 1];
+		if (previous?.quoted === quoted) previous.text += rendered;
+		else groups.push({
+			quoted,
+			text: rendered
+		});
+	}
+	let result = "";
+	for (const [index, group] of groups.entries()) {
+		const rendered = group.quoted ? group.text.split("\n").map((line) => `> ${line}`).join("\n") : group.text;
+		const previous = groups[index - 1];
+		if (result !== "" && (group.quoted || previous?.quoted) && !result.endsWith("\n") && !rendered.startsWith("\n")) result += "\n";
+		result += rendered;
+	}
+	return result;
+}
+function renderAnsiSegment(text, active) {
+	const codes = [];
+	if (has(active, SpanType.Bold)) codes.push(1);
+	if (has(active, SpanType.Italic)) codes.push(3);
+	if (has(active, SpanType.Underline) || has(active, SpanType.Link)) codes.push(4);
+	if (has(active, SpanType.Strike)) codes.push(9);
+	if (has(active, SpanType.Spoiler)) codes.push(8);
+	if (has(active, SpanType.Quote)) codes.push(2);
+	if (has(active, SpanType.Mention) || has(active, SpanType.Hashtag)) codes.push(36);
+	return codes.length === 0 ? text : `\u001b[${codes.join(";")}m${text}\u001b[0m`;
+}
+/**
+* Преобразует текст и wire-разметку API в безопасный HTML, Markdown или ANSI.
+*
+* Некорректные серверные spans игнорируются либо обрезаются по границам строки. Пересекающиеся
+* spans разбиваются на независимые сегменты, поэтому HTML остаётся корректно вложенным.
+* Отсутствующий массив считается пустым; формат по умолчанию — HTML.
+*/
+function renderSpans(content, spans = [], options = {}) {
+	const normalized = normalizedSpans(content, spans);
+	const boundaries = /* @__PURE__ */ new Set([0, content.length]);
+	for (const item of normalized) {
+		boundaries.add(item.start);
+		boundaries.add(item.end);
+	}
+	const points = [...boundaries].sort((left, right) => left - right);
+	const segments = [];
+	for (let index = 0; index < points.length - 1; index += 1) {
+		const start = points[index];
+		const end = points[index + 1];
+		if (start === void 0 || end === void 0 || start === end) continue;
+		const text = content.slice(start, end);
+		const active = normalized.filter((item) => item.start <= start && item.end >= end).map((item) => item.span);
+		segments.push({
+			start,
+			text,
+			active
+		});
+	}
+	const format = options.format ?? SpanRenderFormat.Html;
+	if (format === SpanRenderFormat.Markdown) return renderMarkdown(segments, content, options);
+	let result = "";
+	for (const segment of segments) switch (format) {
+		case SpanRenderFormat.Html:
+			result += renderHtmlSegment(segment.text, segment.active, content, options);
+			break;
+		case SpanRenderFormat.Ansi: result += renderAnsiSegment(segment.text, segment.active);
+	}
+	return result;
+}
+//#endregion
+export { utcStampToIso as C, mapPage as D, Paginator as E, FeatureRegistry as O, toDate as S, PaginationMode as T, IMAGE_MIME_TYPES as _, fromStream as a, isBuilder as b, report as c, autoSpans as d, markup as f, AUDIO_MIME_TYPES as g, ALLOWED_MIME_TYPES as h, isMyProfile as i, ExtensibleOperationCatalog as k, post as l, parseMarkdown as m, renderSpans as n, fromUrl as o, parseHtml as p, statusDays as r, createResources as s, SpanRenderFormat as t, poll as u, VIDEO_MIME_TYPES as v, BaseResource as w, createStatusFeature as x, comment as y };
+
+//# sourceMappingURL=render-C6HRPs10.js.map