itd-api 0.7.2 → 0.9.0

package/dist/shared/{render-mcuELiYi.cjs → render-Dqi8Owqk.cjs}

@@ -1,7 +1,8 @@
-const require_url = require("./url-BaMCQpYH.cjs");
-const require_errors = require("./errors-DfU8M5eS.cjs");
-const require_cookies = require("./cookies-DZwFq6kr.cjs");
-const require_options = require("./options-Dg5N3r1V.cjs");
+const require_url = require("./url-Bsb3xE5U.cjs");
+const require_errors = require("./errors-BmP3TKoW.cjs");
+const require_redact = require("./redact-BP00URmQ.cjs");
+const require_options = require("./options-DOJYtoti.cjs");
+const require_key_value_store = require("./key-value-store-B5GYVEYZ.cjs");
 //#region src/core/feature-catalog.ts
 /**
 * Изменяемый слой над каталогом конкретного API.
@@ -32,6 +33,9 @@ var ExtensibleOperationCatalog = class {
 	get defaultBucket() {
 		return this.#base.defaultBucket;
 	}
+	definitionOf(id) {
+		return this.#operations.get(id) ?? this.#base.definitionOf(id);
+	}
 	retrySafetyOf(id) {
 		return this.#operations.get(id)?.retrySafety ?? this.#base.retrySafetyOf(id);
 	}
@@ -49,7 +53,10 @@ var ExtensibleOperationCatalog = class {
 		if (this.#base.isKnownBucket(name) || this.#bucketOwners.has(name)) throw new require_errors.ItdConfigError(`feature «${owner}»: бакет «${name}» уже зарегистрирован`);
 		this.#bucketOwners.set(name, owner);
 		if (definition.limit !== void 0) this.#bucketLimits[name] = definition.limit;
-		if (definition.concurrency !== void 0) this.#bucketOverrides[name] = Object.freeze({ concurrency: definition.concurrency });
+		if (definition.concurrency !== void 0 || definition.rps !== void 0) this.#bucketOverrides[name] = Object.freeze({
+			...definition.concurrency === void 0 ? {} : { concurrency: definition.concurrency },
+			...definition.rps === void 0 ? {} : { rps: definition.rps }
+		});
 		return () => {
 			if (this.#bucketOwners.get(name) !== owner) return;
 			this.#bucketOwners.delete(name);
@@ -74,22 +81,311 @@ var ExtensibleOperationCatalog = class {
 	}
 };
 //#endregion
+//#region src/core/attachments/url-source.ts
+/** Убирает параметры MIME и приводит его к форме для сравнения. */
+function normalizeMimeType(contentType) {
+	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
+}
+/** Достаёт имя файла из пути URL. */
+function filenameFromUrl(url) {
+	const last = url.pathname.split("/").pop();
+	if (!last) return void 0;
+	try {
+		return decodeURIComponent(last) || void 0;
+	} catch {
+		return last;
+	}
+}
+/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
+function declaredSize(response, maxBytes, url) {
+	const header = response.headers.get("content-length");
+	if (header === null) return void 0;
+	const size = Number(header);
+	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
+	if (maxBytes !== void 0 && size > maxBytes) throw require_options.fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new require_errors.ItdConfigError(`«${require_redact.redactUrl(target)}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_errors.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
+	let response;
+	try {
+		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
+	} catch (error) {
+		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
+		const safeUrl = require_redact.redactUrl(requested.href);
+		throw new require_errors.ItdFileError(`не удалось получить файл по адресу ${safeUrl}`, {
+			reason: require_errors.ItdFileErrorReason.Network,
+			url: safeUrl,
+			retryable: true,
+			cause: require_redact.redactErrorCause(error)
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		const safeUrl = require_redact.redactUrl(finalUrl.href);
+		throw new require_errors.ItdFileError(`источник ${safeUrl} ответил статусом ${response.status}`, {
+			reason: require_errors.ItdFileErrorReason.Http,
+			url: safeUrl,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
+	let size;
+	try {
+		size = declaredSize(response, maxBytes, finalUrl.href);
+	} catch (error) {
+		await response.body?.cancel().catch(() => {});
+		throw error;
+	}
+	return {
+		response,
+		url: finalUrl,
+		size
+	};
+}
+/** Читает ответ с контролем размера до создания итогового `Blob`. */
+async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
+	if (!response.body) {
+		const blob = await response.blob();
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_options.fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = require_options.boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url } = await fetchFile(target, options, context);
+	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	const filename = options.filename ?? filenameFromUrl(url);
+	return {
+		file: new Blob([blob], { type: contentType ?? "" }),
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+/** Открывает HTTP-ответ как ограниченный поток. @internal */
+async function openUrlFile(target, options, context) {
+	const resolved = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) {
+		const safeUrl = require_redact.redactUrl(url.href);
+		throw new require_errors.ItdFileError(`источник ${safeUrl} не предоставил потоковое тело`, {
+			reason: require_errors.ItdFileErrorReason.StreamUnavailable,
+			url: safeUrl
+		});
+	}
+	const stream = require_options.boundedFileStream(response.body, {
+		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+		streamBufferBytes: resolved.streamBufferBytes,
+		...context.signal ? { signal: context.signal } : {},
+		url: url.href,
+		retryableRead: true
+	});
+	const filename = options.filename ?? filenameFromUrl(url);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	return {
+		stream,
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {},
+		...size !== void 0 ? { size } : {},
+		close: () => stream.cancel().catch(() => {})
+	};
+}
+//#endregion
+//#region src/core/attachments/resolver.ts
+/** Возвращает функцию освобождения, которая исполняет действие не более одного раза. */
+function closeOnce(action) {
+	let closing;
+	return () => closing ??= Promise.resolve().then(action);
+}
+/** Добавляет поле только для непустого значения, не выдумывая имя или MIME. */
+function optionalText(name, value) {
+	const normalized = value?.trim();
+	return normalized ? { [name]: normalized } : {};
+}
+/** Единая реализация распознавания и открытия `FileInput`. @internal */
+var DefaultFileResolver = class {
+	#fetch;
+	constructor(fetchImplementation) {
+		this.#fetch = fetchImplementation;
+	}
+	mode(input) {
+		if (typeof input !== "object" || input === null) return require_options.FileTransferMode.Buffer;
+		if ("open" in input) return require_options.FileTransferMode.Stream;
+		if ("url" in input) return require_options.resolveFileStreamOptions(input).mode;
+		return require_options.FileTransferMode.Buffer;
+	}
+	async resolve(input, options = {}, context = {}) {
+		const attempt = context.attempt ?? 1;
+		if (!Number.isInteger(attempt) || attempt < 1) throw new require_errors.ItdConfigError(`attempt должен быть целым числом от 1, получено: ${attempt}`);
+		const maxBytes = require_options.optionalBytes(options.maxBytes, "maxBytes");
+		if (context.signal?.aborted) throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+		const fileContext = {
+			fetch: this.#fetch,
+			attempt,
+			...context.signal ? { signal: context.signal } : {}
+		};
+		try {
+			const source = this.mode(input) === require_options.FileTransferMode.Stream ? await this.#openStream(input, options, fileContext, maxBytes) : await this.#loadBuffer(input, options, fileContext, maxBytes);
+			if (context.signal?.aborted) {
+				if (source.mode === require_options.FileTransferMode.Stream) await source.close();
+				throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			return source;
+		} catch (error) {
+			if (error instanceof require_errors.ItdError || context.signal?.aborted) throw error;
+			throw new require_errors.ItdFileError("не удалось получить содержимое вложения", {
+				reason: require_errors.ItdFileErrorReason.Read,
+				retryable: true,
+				cause: require_redact.redactErrorCause(error)
+			});
+		}
+	}
+	async #loadBuffer(input, options, context, maxBytes) {
+		const content = await this.#resolveBuffer(input, context);
+		if (typeof content !== "object" || content === null || !("file" in content)) throw new require_errors.ItdConfigError("буферный источник должен вернуть объект с полем file");
+		if (!require_redact.isBlob(content.file) && !(content.file instanceof ArrayBuffer) && !ArrayBuffer.isView(content.file)) throw new require_errors.ItdConfigError("поле file должно содержать Blob, ArrayBuffer или Uint8Array");
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(require_redact.isBlob(content.file) ? content.file.type : void 0);
+		const blob = require_redact.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_options.fileTooLarge(void 0, maxBytes, blob.size);
+		return {
+			mode: require_options.FileTransferMode.Buffer,
+			blob,
+			size: blob.size,
+			...optionalText("filename", options.filename ?? content.filename),
+			contentType
+		};
+	}
+	async #openStream(input, options, context, maxBytes) {
+		const opened = await this.#resolveStream(input, context);
+		if (!opened || !require_options.isReadableByteStream(opened.stream)) {
+			await opened?.close?.();
+			throw new require_errors.ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
+		}
+		let handedOff = false;
+		const closeOpened = closeOnce(async () => {
+			await opened.close?.();
+		});
+		try {
+			require_options.optionalBytes(opened.size, "size");
+			if (maxBytes !== void 0 && opened.size !== void 0 && opened.size > maxBytes) throw require_options.fileTooLarge(void 0, maxBytes, opened.size);
+			if (options.requireKnownSize === true && opened.size === void 0) throw new require_errors.ItdConfigError("размер потокового вложения должен быть известен до чтения");
+			const limits = require_options.resolveFileStreamOptions({
+				mode: require_options.FileTransferMode.Stream,
+				...maxBytes !== void 0 ? { maxBytes } : {},
+				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
+			});
+			const stream = require_options.isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : require_options.boundedFileStream(opened.stream, {
+				...limits.maxBytes !== void 0 ? { maxBytes: limits.maxBytes } : {},
+				streamBufferBytes: limits.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {}
+			});
+			let detachAbort;
+			const close = closeOnce(async () => {
+				detachAbort?.();
+				detachAbort = void 0;
+				await stream.cancel().catch(() => {});
+				await closeOpened();
+			});
+			if (context.signal) {
+				const onAbort = () => {
+					close().catch(() => {});
+				};
+				if (context.signal.aborted) {
+					await close();
+					throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+				} else {
+					context.signal.addEventListener("abort", onAbort, { once: true });
+					detachAbort = () => context.signal?.removeEventListener("abort", onAbort);
+				}
+			}
+			handedOff = true;
+			return {
+				mode: require_options.FileTransferMode.Stream,
+				stream,
+				size: opened.size,
+				...optionalText("filename", options.filename ?? opened.filename),
+				contentType: normalizeMimeType(options.contentType ?? opened.contentType),
+				close
+			};
+		} finally {
+			if (!handedOff) await closeOpened();
+		}
+	}
+	#resolveBuffer(input, context) {
+		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || require_redact.isBlob(input)) return {
+			file: input,
+			...require_redact.isFile(input) ? { filename: input.name } : {}
+		};
+		if (typeof input !== "object" || input === null) throw new require_errors.ItdConfigError(`вложение задано значением типа ${typeof input}; ожидается бинарное значение или объект { file }, { url }, { load }, { open }. Для файла на диске используйте fromPath('./photo.jpg') из itd-api/node`);
+		if ("load" in input) return input.load(context);
+		if ("url" in input) {
+			const { url, ...urlOptions } = input;
+			return downloadFile(url, urlOptions, context);
+		}
+		if ("file" in input) return input;
+		if ("open" in input) throw new require_errors.ItdConfigError("потоковый источник нельзя использовать как буферный");
+		throw new require_errors.ItdConfigError("вложение не распознано: ожидается { file }, { url }, { load } или { open }");
+	}
+	#resolveStream(input, context) {
+		if (typeof input === "object" && input !== null && "open" in input) return input.open(context);
+		if (typeof input === "object" && input !== null && "url" in input) {
+			const { url, ...urlOptions } = input;
+			return openUrlFile(url, urlOptions, context);
+		}
+		throw new require_errors.ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
+	}
+};
+/** Создаёт механизм подготовки файлов, привязанный к настроенному `fetch` клиента. @internal */
+function createFileResolver(fetchImplementation) {
+	return new DefaultFileResolver(fetchImplementation);
+}
+//#endregion
 //#region src/core/features.ts
 function requireName(value, kind) {
 	if (typeof value !== "string" || value.trim() === "") throw new require_errors.ItdConfigError(`${kind} должен иметь непустое имя`);
 	return value.trim();
 }
-function requireOperationName(value, featureName) {
-	const name = requireName(value, `Операция feature «${featureName}»`);
-	if (name.includes(".")) throw new require_errors.ItdConfigError(`feature «${featureName}»: локальное имя операции «${name}» не должно содержать точку`);
+function requireFeatureName(value) {
+	const name = requireName(value, "Feature");
+	if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new require_errors.ItdConfigError(`имя feature «${name}» должно соответствовать [a-z][a-z0-9-]*`);
 	return name;
 }
 function validateBucket(owner, localName, bucket) {
 	if (typeof bucket !== "object" || bucket === null || Array.isArray(bucket)) throw new require_errors.ItdConfigError(`feature «${owner}»: бакет «${localName}» должен быть объектом`);
 	if (bucket.limit !== void 0 && (!Number.isFinite(bucket.limit) || bucket.limit <= 0)) throw new require_errors.ItdConfigError(`feature «${owner}»: limit бакета «${localName}» должен быть положительным числом`);
 	if (bucket.concurrency !== void 0 && (!Number.isInteger(bucket.concurrency) || bucket.concurrency < 1)) throw new require_errors.ItdConfigError(`feature «${owner}»: concurrency бакета «${localName}» должен быть целым числом от 1`);
+	if (bucket.rps !== void 0 && (!Number.isFinite(bucket.rps) || bucket.rps <= 0)) throw new require_errors.ItdConfigError(`feature «${owner}»: rps бакета «${localName}» должен быть положительным числом`);
 }
-/** Реестр feature одного facade. @internal */
+/** Реестр подключаемых модулей клиента. @internal */
 var FeatureRegistry = class {
 	#deps;
 	#features = /* @__PURE__ */ new Map();
@@ -102,7 +398,7 @@ var FeatureRegistry = class {
 		this.#deps.assertActive("установить feature");
 		if (this.#disposed) throw new require_errors.ItdStateError("Реестр feature уже освобождён");
 		if (typeof feature !== "object" || feature === null) throw new require_errors.ItdConfigError("feature должен быть объектом");
-		const name = requireName(feature.name, "Feature");
+		const name = requireFeatureName(feature.name);
 		if (this.#features.has(name)) throw new require_errors.ItdConfigError(`feature «${name}» уже установлен`);
 		if (typeof feature.setup !== "function") throw new require_errors.ItdConfigError(`feature «${name}» должен предоставлять setup()`);
 		if (typeof feature.operations !== "object" || feature.operations === null || Array.isArray(feature.operations)) throw new require_errors.ItdConfigError(`feature «${name}» должен объявлять operations`);
@@ -114,6 +410,11 @@ var FeatureRegistry = class {
 		const operations = /* @__PURE__ */ new Map();
 		const controller = new AbortController();
 		let committed = false;
+		const reportRollbackError = (message, error) => {
+			try {
+				this.#deps.logger?.error(message, error);
+			} catch {}
+		};
 		try {
 			for (const service of feature.services ?? []) {
 				const serviceName = requireName(service?.name, `Сервис feature «${name}»`);
@@ -147,7 +448,7 @@ var FeatureRegistry = class {
 				bucketNames.set(localName, globalName);
 			}
 			for (const [rawLocalName, definition] of Object.entries(feature.operations)) {
-				const localName = requireOperationName(rawLocalName, name);
+				const localName = requireName(rawLocalName, `Операция feature «${name}»`);
 				if (typeof definition !== "object" || definition === null) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» должна быть объектом`);
 				if (![
 					"GET",
@@ -159,19 +460,27 @@ var FeatureRegistry = class {
 				if (!Object.values(require_url.RetrySafety).includes(definition.retrySafety)) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» содержит неизвестную retrySafety`);
 				if (definition.service !== void 0 && typeof definition.service !== "string") throw new require_errors.ItdConfigError(`feature «${name}»: service операции «${localName}» должен быть строкой`);
 				if (definition.bucket !== void 0 && typeof definition.bucket !== "string") throw new require_errors.ItdConfigError(`feature «${name}»: bucket операции «${localName}» должен быть строкой`);
+				if (definition.read !== void 0 && typeof definition.read !== "function") throw new require_errors.ItdConfigError(`feature «${name}»: read операции «${localName}» должна быть функцией`);
+				if (definition.annotations !== void 0 && (typeof definition.annotations !== "object" || definition.annotations === null || Array.isArray(definition.annotations))) throw new require_errors.ItdConfigError(`feature «${name}»: annotations операции «${localName}» должны быть объектом`);
 				if (definition.service !== void 0 && !services.has(definition.service)) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный сервис «${definition.service}»`);
 				const bucket = definition.bucket === void 0 ? this.#deps.catalog.defaultBucket : bucketNames.get(definition.bucket);
 				if (bucket === void 0) throw new require_errors.ItdConfigError(`feature «${name}»: операция «${localName}» ссылается на необъявленный бакет «${definition.bucket}»`);
 				const operationId = `${name}.${localName}`;
-				const unregister = this.#deps.catalog.registerOperation(name, operationId, {
+				const contract = require_url.defineOperation(operationId, {
 					method: definition.method,
 					retrySafety: definition.retrySafety,
-					bucket
+					bucket,
+					...definition.annotations === void 0 ? {} : { annotations: definition.annotations }
+				}, definition.read ?? require_url.identityResult);
+				const unregister = this.#deps.catalog.registerOperation(name, operationId, {
+					method: contract.method,
+					retrySafety: contract.retrySafety,
+					bucket,
+					...contract.annotations === void 0 ? {} : { annotations: contract.annotations }
 				});
 				rollback.push(unregister);
 				operations.set(localName, {
-					operationId,
-					method: definition.method,
+					contract,
 					service: definition.service
 				});
 			}
@@ -181,6 +490,15 @@ var FeatureRegistry = class {
 				signal: controller.signal,
 				clock: this.#deps.clock,
 				logger: this.#deps.logger,
+				files: Object.freeze({ resolve: (input, options, context) => {
+					try {
+						this.#deps.assertActive(`открыть файловый источник feature «${name}»`);
+						if (!committed || controller.signal.aborted) throw new require_errors.ItdStateError(`feature «${name}» не активен`);
+						return this.#deps.files.resolve(input, options, context);
+					} catch (error) {
+						return Promise.reject(error);
+					}
+				} }),
 				request: (operation, options) => {
 					try {
 						this.#deps.assertActive(`выполнить операцию feature «${name}»`);
@@ -194,10 +512,8 @@ var FeatureRegistry = class {
 						delete scoped.baseUrl;
 						delete scoped.retrySafety;
 						delete scoped.rateLimitBucket;
-						return this.#deps.http.request({
+						return this.#deps.http.execute(resolved.contract, {
 							...scoped,
-							operationId: resolved.operationId,
-							method: resolved.method,
 							...resolved.service === void 0 ? {} : { service: resolved.service }
 						});
 					} catch (error) {
@@ -207,6 +523,43 @@ var FeatureRegistry = class {
 				serviceBaseUrl: (serviceName) => {
 					if (!services.has(serviceName)) throw new require_errors.ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
 					return this.#deps.services.resolveBaseUrl(serviceName);
+				},
+				connection: (serviceName) => {
+					if (!services.has(serviceName)) throw new require_errors.ItdConfigError(`feature «${name}» не объявляет сервис «${serviceName}»`);
+					return this.#deps.connection(serviceName);
+				},
+				manage: (resource) => {
+					this.#deps.assertActive(`зарегистрировать ресурс feature «${name}»`);
+					if (controller.signal.aborted) throw new require_errors.ItdStateError(`feature «${name}» не активен`);
+					const unregister = this.#deps.manage(resource);
+					let registered = true;
+					const release = () => {
+						if (!registered) return;
+						registered = false;
+						unregister();
+					};
+					if (!committed) rollback.push(() => {
+						if (!registered) return;
+						if (committed) {
+							release();
+							return;
+						}
+						try {
+							resource.stop();
+						} catch (error) {
+							reportRollbackError(`Не удалось остановить ресурс «${resource.kind}» при откате feature «${name}»`, error);
+						} finally {
+							release();
+						}
+						Promise.resolve().then(() => resource.drain()).catch((error) => {
+							reportRollbackError(`Не удалось освободить ресурс «${resource.kind}» при откате feature «${name}»`, error);
+						});
+					});
+					return release;
+				},
+				assertActive: (action) => {
+					this.#deps.assertActive(action);
+					if (!committed || controller.signal.aborted) throw new require_errors.ItdStateError(`feature «${name}» не активен`);
 				}
 			});
 			const installation = feature.setup(context);
@@ -235,36 +588,166 @@ var FeatureRegistry = class {
 		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);
-		}
+		const errors = (await Promise.allSettled([...this.#features.values()].reverse().map(async (feature) => feature.close?.()))).filter((result) => result.status === "rejected").map((result) => result.reason);
 		if (errors.length > 0) throw new AggregateError(errors, "Не удалось закрыть feature");
 	}
 	async dispose() {
 		if (this.#disposed) return;
 		this.#disposed = true;
 		const errors = [];
-		for (const feature of [...this.#features.values()].reverse()) {
+		const disposals = [];
+		const features = [...this.#features.values()].reverse();
+		for (const feature of features) {
 			feature.controller.abort(new require_errors.ItdAbortError(`Feature «${feature.name}» освобождён`));
 			try {
-				await feature.dispose?.();
-			} catch (error) {
-				errors.push(error);
-			}
-			for (const cleanup of [...feature.cleanup].reverse()) try {
-				cleanup();
+				disposals.push(Promise.resolve(feature.dispose?.()).then(() => void 0));
 			} catch (error) {
 				errors.push(error);
 			}
 		}
+		for (const feature of features) for (const cleanup of [...feature.cleanup].reverse()) try {
+			cleanup();
+		} catch (error) {
+			errors.push(error);
+		}
 		this.#features.clear();
+		const results = await Promise.allSettled(disposals);
+		for (const result of results) if (result.status === "rejected") errors.push(result.reason);
 		if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить feature");
 	}
 };
 //#endregion
+//#region src/core/managed-resources.ts
+/** Реестр активных ресурсов клиента. @internal */
+var ManagedResourceRegistry = class {
+	#resources = /* @__PURE__ */ new Set();
+	#disposed = false;
+	register(resource) {
+		if (this.#disposed) throw new require_errors.ItdStateError("Lifecycle клиента уже освобождён");
+		if (typeof resource !== "object" || resource === null || typeof resource.kind !== "string" || resource.kind.trim() === "" || typeof resource.stop !== "function" || typeof resource.drain !== "function") throw new require_errors.ItdConfigError("Managed resource должен предоставлять kind, stop() и drain()");
+		this.#resources.add(resource);
+		let registered = true;
+		return () => {
+			if (!registered) return;
+			registered = false;
+			this.#resources.delete(resource);
+		};
+	}
+	/** Останавливает snapshot синхронно, чтобы новые auth-данные ещё не были опубликованы. */
+	stopAll() {
+		const resources = [...this.#resources];
+		const errors = [];
+		for (const resource of resources) try {
+			resource.stop();
+		} catch (error) {
+			errors.push(error);
+		}
+		return {
+			resources,
+			errors
+		};
+	}
+	dispose() {
+		this.#disposed = true;
+		this.#resources.clear();
+	}
+};
+//#endregion
+//#region src/core/feature-host.ts
+/**
+* Управляет подключаемыми модулями и их ресурсами.
+*
+* @internal
+*/
+var ClientFeatureHost = class {
+	#runtime;
+	#features;
+	#resources = new ManagedResourceRegistry();
+	/** Общий файловый порт ресурсов и подключаемых модулей этого клиента. @internal */
+	files;
+	constructor(runtime, options) {
+		this.#runtime = runtime;
+		this.files = createFileResolver(runtime.config.fetch);
+		this.#features = new FeatureRegistry({
+			http: runtime.http,
+			services: runtime.services,
+			serviceOverrides: runtime.config.services,
+			catalog: options.catalog,
+			baseUrl: runtime.config.baseUrl,
+			clock: runtime.config.clock,
+			logger: runtime.config.logger,
+			files: this.files,
+			assertActive: options.assertActive,
+			connection: (serviceName) => runtime.connection(serviceName),
+			manage: (resource) => this.#resources.register(resource),
+			registerBucket: (name, definition) => runtime.registerRateLimitBucket(name, definition)
+		});
+	}
+	install(feature) {
+		return this.#features.install(feature);
+	}
+	names() {
+		return this.#features.names();
+	}
+	has(name) {
+		return this.#features.has(name);
+	}
+	/** Регистрирует ресурс самого клиента. @internal */
+	manage(resource) {
+		return this.#resources.register(resource);
+	}
+	/** Останавливает ресурсы перед сменой авторизации. */
+	stop() {
+		const { errors } = this.#resources.stopAll();
+		if (errors.length > 0) this.#runtime.config.logger?.error("Не удалось остановить ресурсы клиента", errors);
+	}
+	/** Останавливает ресурсы и ждёт функции закрытия модулей. */
+	async close() {
+		const snapshot = this.#resources.stopAll();
+		const errors = [...snapshot.errors];
+		const deadline = require_url.createDeadline(this.#runtime.config.shutdownTimeout, this.#runtime.config.clock);
+		const tasks = [...snapshot.resources.map((resource) => ({
+			kind: resource.kind,
+			promise: Promise.resolve().then(() => resource.drain())
+		})), {
+			kind: "feature lifecycle",
+			promise: Promise.resolve().then(() => this.#features.close())
+		}];
+		try {
+			const stuck = (await Promise.all(tasks.map(async ({ kind, promise }) => {
+				const result = promise.catch((error) => {
+					errors.push(error);
+				});
+				return await deadline.wait(result) ? void 0 : kind;
+			}))).filter((kind) => kind !== void 0);
+			if (stuck.length > 0) errors.push(new require_errors.ItdStateError(`ресурсы (${stuck.join(", ")}) не завершились за ${this.#runtime.config.shutdownTimeout} мс`));
+		} finally {
+			deadline.cancel();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Не удалось закрыть feature-host");
+	}
+	async dispose() {
+		this.#resources.dispose();
+		const deadline = require_url.createDeadline(this.#runtime.config.shutdownTimeout, this.#runtime.config.clock);
+		let failed = false;
+		let failure;
+		const settled = this.#features.dispose().catch((error) => {
+			failed = true;
+			failure = error;
+		});
+		try {
+			if (!await deadline.wait(settled)) throw new require_errors.ItdStateError(`освобождение подключаемых модулей не завершилось за ${this.#runtime.config.shutdownTimeout} мс`);
+		} finally {
+			deadline.cancel();
+		}
+		if (failed) throw failure;
+	}
+};
+function createFeatureHost(runtime, options) {
+	return new ClientFeatureHost(runtime, options);
+}
+//#endregion
 //#region src/resources/pagination.ts
 /** Схема пагинации эндпоинта. */
 const PaginationMode = Object.freeze({
@@ -382,6 +865,10 @@ function readOffsetPage(body, field, offset) {
 		raw: body
 	};
 }
+/** Создаёт единый контракт пагинированной операции. */
+function pageOperation(id, read) {
+	return require_url.defineBuiltInOperation(id, read);
+}
 /**
 * Перебор страниц списка.
 *
@@ -507,6 +994,10 @@ var BaseResource = class {
 	constructor(http) {
 		this.http = http;
 	}
+	/** Выполняет операцию без возвращаемого значения и отбрасывает служебное тело ответа. */
+	voidOperation(operation, options) {
+		return this.http.execute(operation, options);
+	}
 	/**
 	* Собирает перебор страниц.
 	*
@@ -532,24 +1023,22 @@ var BaseResource = class {
 	* @example
 	* ```ts
 	* #feed = this.paginated<Post, FeedParams>({
-	*   operationId: 'posts.list',
+	*   operation: 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, {
+			const operation = typeof spec.operation === "function" ? spec.operation(params) : spec.operation;
+			return this.http.execute(operation, {
 				path: spec.path(params),
 				query: withPageState(spec.query(params), state),
 				...options
 			});
-			return spec.read(body, state);
 		};
 		return {
 			list: (params, options) => load(params, spec.start(params), options),
@@ -574,6 +1063,163 @@ function withPageState(query, state) {
 	};
 }
 //#endregion
+//#region src/resources/notifications.ts
+const NOTIFICATIONS_LIST = pageOperation("notifications.list", (body, request) => {
+	const offset = Number(request.query?.offset ?? 0);
+	const page = readOffsetPage(body, "notifications", Number.isFinite(offset) ? offset : 0);
+	return {
+		...page,
+		items: page.items.map(require_url.normalizeNotification)
+	};
+});
+const NOTIFICATIONS_COUNT = require_url.defineBuiltInOperation("notifications.count", (body) => require_url.pickNumber(body, "count", 0));
+const markedCountOperation = (id) => require_url.defineBuiltInOperation(id, (body) => require_url.pickNumber(body, "markedCount", 0));
+const NOTIFICATIONS_MARK_READ = markedCountOperation("notifications.markRead");
+const NOTIFICATIONS_MARK_READ_BATCH = markedCountOperation("notifications.markReadBatch");
+const NOTIFICATIONS_MARK_ALL_READ = markedCountOperation("notifications.markAllRead");
+const NOTIFICATIONS_GET_SETTINGS = require_url.defineBuiltInOperation("notifications.getSettings", readSettings);
+const NOTIFICATIONS_UPDATE_SETTINGS = require_url.defineBuiltInOperation("notifications.updateSettings", readSettings);
+const NOTIFICATION_SETTING_KEYS = [
+	"enabled",
+	"sound",
+	"follows",
+	"wallPosts",
+	"likes",
+	"comments",
+	"mentions"
+];
+/**
+* Сколько идентификаторов уходит в одном запросе на отметку прочтения.
+*
+* Столько же отправляет сайт итд.com — значит на сервере, скорее всего, есть ограничение.
+*/
+const READ_BATCH_SIZE = 20;
+/**
+* Читает настройки уведомлений.
+*
+* Сервер отдаёт плоский объект: `enabled`, `sound`, `follows`, `wallPosts`, `likes`,
+* `comments`, `mentions`. Отсутствующая настройка считается включённой — так же
+* ведёт себя сайт итд.com.
+*/
+function readSettings(body) {
+	const settings = {};
+	for (const key of NOTIFICATION_SETTING_KEYS) settings[key] = require_url.pickBoolean(body, key, true);
+	return settings;
+}
+/**
+* Уведомления: список, счётчик, отметки о прочтении, настройки.
+*
+* Доступна как `itd.notifications`. Все уведомления приведены к единой форме, поэтому
+* объекты отсюда и из потока событий можно складывать в один список.
+*/
+var NotificationsResource = class extends BaseResource {
+	/** Уведомления: `/api/notifications/`, пагинация по смещению. */
+	#list = this.paginated({
+		operation: NOTIFICATIONS_LIST,
+		path: () => "/api/notifications/",
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => ({ offset: p.offset ?? 0 }),
+		mode: PaginationMode.Offset
+	});
+	/**
+	* Загружает страницу уведомлений.
+	*
+	* Пагинация здесь основана на смещении.
+	*
+	* @example
+	* ```ts
+	* const page = await itd.notifications.list({ limit: 20 });
+	* const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
+	* ```
+	*/
+	list(params = {}, options = {}) {
+		return this.#list.list(params, options);
+	}
+	/**
+	* Перебирает уведомления.
+	*
+	* @example
+	* ```ts
+	* for await (const notification of itd.notifications.iterate()) {
+	*   console.log(formatNotificationText(notification));
+	* }
+	* ```
+	*/
+	iterate(params = {}, options = {}) {
+		return this.#list.iterate(params, options);
+	}
+	/** Загружает число непрочитанных уведомлений. */
+	count(options = {}) {
+		return this.http.execute(NOTIFICATIONS_COUNT, {
+			path: "/api/notifications/count",
+			...options
+		});
+	}
+	/**
+	* Отмечает уведомление прочитанным.
+	*
+	* @returns сколько записей отметил сервер
+	*/
+	markRead(notificationId, options = {}) {
+		return this.http.execute(NOTIFICATIONS_MARK_READ, {
+			path: `/api/notifications/${require_redact.encodePathSegment(notificationId, "notificationId")}/read`,
+			...options
+		});
+	}
+	/**
+	* Отмечает прочитанными сразу несколько уведомлений.
+	*
+	* Список автоматически режется на части по 20 идентификаторов — столько же отправляет
+	* сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
+	* результат суммируется.
+	*
+	* @returns сколько записей отметил сервер суммарно
+	*/
+	async markReadBatch(ids, options = {}) {
+		let marked = 0;
+		for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
+			const chunk = ids.slice(index, index + READ_BATCH_SIZE);
+			marked += await this.http.execute(NOTIFICATIONS_MARK_READ_BATCH, {
+				path: "/api/notifications/read-batch",
+				body: { ids: chunk },
+				...options
+			});
+		}
+		return marked;
+	}
+	/** Отмечает прочитанными все уведомления. */
+	markAllRead(options = {}) {
+		return this.http.execute(NOTIFICATIONS_MARK_ALL_READ, {
+			path: "/api/notifications/read-all",
+			...options
+		});
+	}
+	/** Загружает настройки уведомлений. */
+	getSettings(options = {}) {
+		return this.http.execute(NOTIFICATIONS_GET_SETTINGS, {
+			path: "/api/notifications/settings",
+			...options
+		});
+	}
+	/**
+	* Обновляет настройки уведомлений.
+	*
+	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
+	*/
+	async updateSettings(input, options = {}) {
+		const payload = {};
+		for (const key of NOTIFICATION_SETTING_KEYS) {
+			const value = input[key];
+			if (value !== void 0) payload[key] = value;
+		}
+		return this.http.execute(NOTIFICATIONS_UPDATE_SETTINGS, {
+			path: "/api/notifications/settings",
+			body: payload,
+			...options
+		});
+	}
+};
+//#endregion
 //#region src/domain/time.ts
 const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
 /**
@@ -627,11 +1273,11 @@ var StatusResource = class {
 	constructor(context) {
 		this.#context = context;
 	}
-	async get(options = {}) {
-		return normalizeStatus(await this.#context.request("get", {
+	get(options = {}) {
+		return this.#context.request("get", {
 			path: "/api/status",
 			...options
-		}));
+		});
 	}
 };
 /** Встроенный модуль страницы состояния платформы. @internal */
@@ -646,7 +1292,8 @@ function createStatusFeature() {
 		operations: { get: {
 			method: "GET",
 			retrySafety: require_url.RetrySafety.Safe,
-			service: require_url.STATUS_SERVICE
+			service: require_url.STATUS_SERVICE,
+			read: (body) => normalizeStatus(body)
 		} },
 		setup: (context) => ({ api: new StatusResource(context) })
 	};
@@ -811,6 +1458,13 @@ function resolveComment(input, allowReplyTo = false) {
 }
 //#endregion
 //#region src/resources/comments.ts
+const COMMENTS_REPLIES = pageOperation("comments.replies", (body) => readPagedPage(body, "replies"));
+const COMMENTS_REPLY = require_url.passthroughOperation("comments.reply");
+const COMMENTS_UPDATE = require_url.passthroughOperation("comments.update");
+const COMMENTS_RESTORE = require_url.passthroughOperation("comments.restore");
+const COMMENTS_LIKE = require_url.passthroughOperation("comments.like");
+const COMMENTS_UNLIKE = require_url.passthroughOperation("comments.unlike");
+const COMMENTS_REMOVE = require_url.voidOperation("comments.remove");
 /**
 * Комментарии и ответы на них.
 *
@@ -821,11 +1475,10 @@ var CommentsResource = class extends BaseResource {
 	#uploadFiles;
 	/** Ответы на комментарий: `/api/comments/{id}/replies`, постраничная пагинация. */
 	#replies = this.paginated({
-		operationId: "comments.replies",
-		path: (p) => `/api/comments/${require_cookies.encodePathSegment(p.commentId, "commentId")}/replies`,
+		operation: COMMENTS_REPLIES,
+		path: (p) => `/api/comments/${require_redact.encodePathSegment(p.commentId, "commentId")}/replies`,
 		query: (p) => ({ limit: p.limit }),
 		start: (p) => p.page !== void 0 ? { page: p.page } : {},
-		read: (body) => readPagedPage(body, "replies"),
 		mode: PaginationMode.Page
 	});
 	constructor(http, deps) {
@@ -864,8 +1517,8 @@ var CommentsResource = class extends BaseResource {
 		const existing = data.attachmentIds ?? [];
 		const files = data.files ?? [];
 		const attachmentIds = files.length > 0 ? [...existing, ...await this.#uploadFiles(files, options)] : existing;
-		return this.http.operation("comments.reply", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/replies`,
+		return this.http.execute(COMMENTS_REPLY, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/replies`,
 			body: {
 				content: data.content ?? "",
 				attachmentIds,
@@ -876,176 +1529,42 @@ var CommentsResource = class extends BaseResource {
 	}
 	/** Редактирует текст комментария. */
 	update(commentId, content, options = {}) {
-		return this.http.operation("comments.update", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}`,
+		return this.http.execute(COMMENTS_UPDATE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}`,
 			body: { content },
 			...options
 		});
 	}
 	/** Удаляет комментарий. Восстановить его можно через {@link restore}. */
 	remove(commentId, options = {}) {
-		return this.http.operation("comments.remove", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}`,
+		return this.voidOperation(COMMENTS_REMOVE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый комментарий. */
 	restore(commentId, options = {}) {
-		return this.http.operation("comments.restore", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/restore`,
+		return this.http.execute(COMMENTS_RESTORE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на комментарий. */
 	like(commentId, options = {}) {
-		return this.http.operation("comments.like", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/like`,
+		return this.http.execute(COMMENTS_LIKE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с комментария. */
 	unlike(commentId, options = {}) {
-		return this.http.operation("comments.unlike", {
-			path: `/api/comments/${require_cookies.encodePathSegment(commentId, "commentId")}/like`,
+		return this.http.execute(COMMENTS_UNLIKE, {
+			path: `/api/comments/${require_redact.encodePathSegment(commentId, "commentId")}/like`,
 			...options
 		});
 	}
 };
 //#endregion
-//#region src/core/attachments/url-source.ts
-/** Убирает параметры MIME и приводит его к форме для сравнения. */
-function normalizeMimeType(contentType) {
-	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
-}
-/** Достаёт имя файла из пути URL. */
-function filenameFromUrl(url) {
-	const last = url.pathname.split("/").pop();
-	if (!last) return void 0;
-	try {
-		return decodeURIComponent(last) || void 0;
-	} catch {
-		return last;
-	}
-}
-/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
-function declaredSize(response, maxBytes, url) {
-	const header = response.headers.get("content-length");
-	if (header === null) return void 0;
-	const size = Number(header);
-	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
-	if (maxBytes !== void 0 && size > maxBytes) throw require_options.fileTooLarge(url, maxBytes, size);
-	return size;
-}
-/** Получает HTTP-ответ источника и проверяет его статус. */
-async function fetchFile(target, options, context) {
-	let requested;
-	try {
-		requested = new URL(target);
-	} catch {
-		throw new require_errors.ItdConfigError(`«${target}» не разбирается как адрес`);
-	}
-	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_errors.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
-	let response;
-	try {
-		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
-	} catch (error) {
-		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
-		throw new require_errors.ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
-			reason: require_errors.ItdFileErrorReason.Network,
-			url: requested.href,
-			retryable: true,
-			cause: error
-		});
-	}
-	const finalUrl = response.url ? new URL(response.url) : requested;
-	if (!response.ok) {
-		await response.body?.cancel().catch(() => {});
-		throw new require_errors.ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
-			reason: require_errors.ItdFileErrorReason.Http,
-			url: finalUrl.href,
-			status: response.status,
-			retryable: response.status === 408 || response.status === 429 || response.status >= 500
-		});
-	}
-	const { maxBytes } = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
-	let size;
-	try {
-		size = declaredSize(response, maxBytes, finalUrl.href);
-	} catch (error) {
-		await response.body?.cancel().catch(() => {});
-		throw error;
-	}
-	return {
-		response,
-		url: finalUrl,
-		size
-	};
-}
-/** Читает ответ с контролем размера до создания итогового `Blob`. */
-async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
-	if (!response.body) {
-		const blob = await response.blob();
-		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_options.fileTooLarge(url, maxBytes, blob.size);
-		return blob;
-	}
-	const chunks = [];
-	const reader = require_options.boundedFileStream(response.body, {
-		...maxBytes !== void 0 ? { maxBytes } : {},
-		streamBufferBytes,
-		...signal ? { signal } : {},
-		url,
-		retryableRead: true
-	}).getReader();
-	try {
-		for (;;) {
-			const next = await reader.read();
-			if (next.done) break;
-			chunks.push(next.value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
-}
-/** Скачивает файл целиком с ограничением размера. @internal */
-async function downloadFile(target, options, context) {
-	const resolved = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
-	const { response, url } = await fetchFile(target, options, context);
-	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
-	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
-	const filename = options.filename ?? filenameFromUrl(url);
-	return {
-		file: new Blob([blob], { type: contentType ?? "" }),
-		...filename ? { filename } : {},
-		...contentType ? { contentType } : {}
-	};
-}
-/** Открывает HTTP-ответ как ограниченный поток. @internal */
-async function openUrlFile(target, options, context) {
-	const resolved = require_options.resolveFileStreamOptions(options, require_options.DEFAULT_URL_FILE_MAX_BYTES);
-	const { response, url, size } = await fetchFile(target, options, context);
-	if (!response.body) throw new require_errors.ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
-		reason: require_errors.ItdFileErrorReason.StreamUnavailable,
-		url: url.href
-	});
-	const stream = require_options.boundedFileStream(response.body, {
-		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
-		streamBufferBytes: resolved.streamBufferBytes,
-		...context.signal ? { signal: context.signal } : {},
-		url: url.href,
-		retryableRead: true
-	});
-	const filename = options.filename ?? filenameFromUrl(url);
-	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
-	return {
-		stream,
-		...filename ? { filename } : {},
-		...contentType ? { contentType } : {},
-		...size !== void 0 ? { size } : {},
-		close: () => stream.cancel().catch(() => {})
-	};
-}
-//#endregion
 //#region src/core/multipart.ts
 const encoder = new TextEncoder();
 /** Убирает возможность внедрить дополнительный multipart-заголовок через имя файла. */
@@ -1182,12 +1701,17 @@ function assertAllowedMime(mimeType, filename) {
 	if (!mimeType) throw new require_errors.ItdConfigError(`Не удалось определить тип файла${filename ? ` «${filename}»` : ""}. Укажите его явно: { file, filename, contentType }.`);
 	if (!isAllowedMime(mimeType)) throw new require_errors.ItdConfigError(`Тип «${mimeType}» не поддерживается загрузкой. Допустимые: ${ALLOWED_MIME_TYPES.join(", ")}.`);
 }
+//#endregion
+//#region src/resources/files.ts
+const FILES_UPLOAD = require_url.passthroughOperation("files.upload");
+const FILES_GET = require_url.passthroughOperation("files.get");
+const FILES_REMOVE = require_url.voidOperation("files.remove");
 /** Файлы и медиа. */
 var FilesResource = class extends BaseResource {
-	#fetch;
+	#files;
 	constructor(http, deps) {
 		super(http);
-		this.#fetch = deps.fetch;
+		this.#files = deps.files;
 	}
 	/**
 	* Загружает файл и возвращает его идентификатор.
@@ -1197,7 +1721,7 @@ var FilesResource = class extends BaseResource {
 	*/
 	upload(input, uploadOptions = {}, requestOptions = {}) {
 		const bodyFactory = this.#createBodyFactory(input, uploadOptions);
-		return this.http.operation("files.upload", {
+		return this.http.execute(FILES_UPLOAD, {
 			path: "/api/files/upload",
 			bodyFactory,
 			...requestOptions,
@@ -1216,372 +1740,150 @@ var FilesResource = class extends BaseResource {
 	* Для ещё не прикреплённого файла сервер может ответить `404`.
 	*/
 	get(fileId, options = {}) {
-		return this.http.operation("files.get", {
-			path: `/api/files/${require_cookies.encodePathSegment(fileId, "fileId")}`,
+		return this.http.execute(FILES_GET, {
+			path: `/api/files/${require_redact.encodePathSegment(fileId, "fileId")}`,
 			...options
 		});
 	}
 	/** Удаляет загруженный файл. */
 	remove(fileId, options = {}) {
-		return this.http.operation("files.remove", {
-			path: `/api/files/${require_cookies.encodePathSegment(fileId, "fileId")}`,
-			...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 require_errors.ItdError || signal.aborted) throw error;
-				throw new require_errors.ItdFileError("не удалось получить содержимое вложения", {
-					reason: require_errors.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 require_options.resolveFileStreamOptions(input).mode === require_options.FileTransferMode.Stream;
-		return false;
-	}
-	/** Получает и проверяет буферный источник. */
-	async #prepareBuffer(input, options, context) {
-		const content = await this.#resolveBuffer(input, context);
-		const filename = options.filename ?? content.filename ?? this.#nameFromMime(options.contentType ?? content.contentType);
-		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(require_url.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
-		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
-		const blob = require_url.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
-		const limits = require_options.resolveFileStreamOptions(options);
-		if (limits.maxBytes !== void 0 && blob.size > limits.maxBytes) throw new require_errors.ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${blob.size}`, {
-			reason: require_errors.ItdFileErrorReason.TooLarge,
-			limit: limits.maxBytes,
-			actual: blob.size
-		});
-		return {
-			mode: "buffer",
-			blob,
-			filename
-		};
-	}
-	/** Открывает и проверяет потоковый источник. */
-	async #prepareStream(input, options, context) {
-		let opened;
-		if (typeof input === "object" && input !== null && "open" in input) opened = await input.open(context);
-		else if (typeof input === "object" && input !== null && "url" in input) {
-			const { url, ...urlOptions } = input;
-			opened = await openUrlFile(url, urlOptions, context);
-		} else throw new require_errors.ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
-		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
-			await opened?.close?.();
-			throw new require_errors.ItdConfigError("потоковый источник должен вернуть { stream: ReadableStream }");
-		}
-		try {
-			const filename = options.filename ?? opened.filename ?? this.#nameFromMime(options.contentType ?? opened.contentType);
-			const contentType = normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
-			if (options.validateMime !== false) assertAllowedMime(contentType, filename);
-			const limits = require_options.resolveFileStreamOptions({
-				mode: require_options.FileTransferMode.Stream,
-				...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
-				...options.streamBufferBytes !== void 0 ? { streamBufferBytes: options.streamBufferBytes } : {}
-			});
-			if (limits.maxBytes !== void 0 && opened.size !== void 0 && opened.size > limits.maxBytes) throw new require_errors.ItdFileError(`файл больше предела в ${limits.maxBytes} байт: ${opened.size}`, {
-				reason: require_errors.ItdFileErrorReason.TooLarge,
-				limit: limits.maxBytes,
-				actual: opened.size
-			});
-			return {
-				mode: "stream",
-				stream: require_options.isBoundedFileStream(opened.stream) && options.maxBytes === void 0 && options.streamBufferBytes === void 0 ? opened.stream : require_options.boundedFileStream(opened.stream, {
-					...limits.maxBytes !== void 0 ? { maxBytes: limits.maxBytes } : {},
-					streamBufferBytes: limits.streamBufferBytes,
-					signal: context.signal
-				}),
-				filename,
-				contentType: contentType ?? "",
-				...opened.close ? { close: opened.close } : {}
-			};
-		} catch (error) {
-			await opened.close?.();
-			throw error;
-		}
-	}
-	/** Разрешает только буферные формы. */
-	#resolveBuffer(input, context) {
-		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || require_url.isBlob(input)) return {
-			file: input,
-			...require_url.isFile(input) ? { filename: input.name } : {}
-		};
-		if (typeof input !== "object" || input === null) throw new require_errors.ItdConfigError(`вложение задано значением типа ${typeof input}; ожидается бинарное значение или объект { file }, { url }, { load }, { open }. Для файла на диске используйте fromPath('./photo.jpg') из itd-api/node`);
-		if ("load" in input) return input.load(context);
-		if ("url" in input) {
-			const { url, ...urlOptions } = input;
-			return downloadFile(url, urlOptions, context);
-		}
-		if ("file" in input) return input;
-		if ("open" in input) throw new require_errors.ItdConfigError("потоковый источник нельзя использовать как буферный");
-		throw new require_errors.ItdConfigError("вложение не распознано: ожидается { file }, { url }, { load } или { open }");
-	}
-	/** Подбирает непустое имя, обязательное для multipart. */
-	#nameFromMime(contentType) {
-		const extension = normalizeMimeType(contentType)?.split("/")[1];
-		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/${require_cookies.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 require_url.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 require_url.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] = require_url.pickBoolean(body, key, true);
-	return settings;
-}
-/**
-* Уведомления: список, счётчик, отметки о прочтении, настройки.
-*
-* Доступна как `itd.notifications`. Все уведомления приведены к единой форме, поэтому
-* объекты отсюда и из потока событий можно складывать в один список.
-*/
-var NotificationsResource = class extends BaseResource {
-	/** Уведомления: `/api/notifications/`, пагинация по смещению. */
-	#list = this.paginated({
-		operationId: "notifications.list",
-		path: () => "/api/notifications/",
-		query: (p) => ({ limit: p.limit }),
-		start: (p) => ({ offset: p.offset ?? 0 }),
-		read: (body, state) => {
-			const page = readOffsetPage(body, "notifications", state.offset ?? 0);
-			return {
-				...page,
-				items: page.items.map(require_url.normalizeNotification)
-			};
-		},
-		mode: PaginationMode.Offset
-	});
-	/**
-	* Загружает страницу уведомлений.
-	*
-	* Пагинация здесь основана на смещении.
-	*
-	* @example
-	* ```ts
-	* const page = await itd.notifications.list({ limit: 20 });
-	* const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
-	* ```
-	*/
-	list(params = {}, options = {}) {
-		return this.#list.list(params, options);
-	}
-	/**
-	* Перебирает уведомления.
-	*
-	* @example
-	* ```ts
-	* for await (const notification of itd.notifications.iterate()) {
-	*   console.log(formatNotificationText(notification));
-	* }
-	* ```
-	*/
-	iterate(params = {}, options = {}) {
-		return this.#list.iterate(params, options);
-	}
-	/** Загружает число непрочитанных уведомлений. */
-	async count(options = {}) {
-		const body = await this.http.operation("notifications.count", {
-			path: "/api/notifications/count",
-			...options
-		});
-		return require_url.pickNumber(body, "count", 0);
-	}
-	/**
-	* Отмечает уведомление прочитанным.
-	*
-	* @returns сколько записей отметил сервер
-	*/
-	async markRead(notificationId, options = {}) {
-		const body = await this.http.operation("notifications.markRead", {
-			path: `/api/notifications/${require_cookies.encodePathSegment(notificationId, "notificationId")}/read`,
+		return this.voidOperation(FILES_REMOVE, {
+			path: `/api/files/${require_redact.encodePathSegment(fileId, "fileId")}`,
 			...options
 		});
-		return require_url.pickNumber(body, "markedCount", 0);
 	}
 	/**
-	* Отмечает прочитанными сразу несколько уведомлений.
-	*
-	* Список автоматически режется на части по 20 идентификаторов — столько же отправляет
-	* сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
-	* результат суммируется.
-	*
-	* @returns сколько записей отметил сервер суммарно
+	* Создаёт фабрику тела. Успешно подготовленный буфер кешируется, а поток открывается
+	* заново, поэтому каждая транспортная попытка получает непрочитанное тело.
 	*/
-	async markReadBatch(ids, options = {}) {
-		let marked = 0;
-		for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
-			const chunk = ids.slice(index, index + READ_BATCH_SIZE);
-			const body = await this.http.operation("notifications.markReadBatch", {
-				path: "/api/notifications/read-batch",
-				body: { ids: chunk },
-				...options
+	#createBodyFactory(input, options) {
+		const streamMode = this.#files.mode(input) === require_options.FileTransferMode.Stream;
+		let buffered;
+		return async ({ signal, attempt }) => {
+			let prepared;
+			if (streamMode) prepared = await this.#files.resolve(input, options, {
+				signal,
+				attempt
 			});
-			marked += require_url.pickNumber(body, "markedCount", 0);
-		}
-		return marked;
+			else {
+				buffered ??= this.#files.resolve(input, options, {
+					signal,
+					attempt
+				}).then((source) => source).catch((error) => {
+					buffered = void 0;
+					throw error;
+				});
+				prepared = await buffered;
+			}
+			if (prepared.mode === require_options.FileTransferMode.Buffer) {
+				const filename = this.#filename(prepared, options);
+				const contentType = prepared.contentType ?? mimeFromFilename(filename);
+				if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+				const blob = !contentType || prepared.blob.type === contentType ? prepared.blob : new Blob([prepared.blob], { type: contentType });
+				const form = new FormData();
+				form.set("file", blob, filename);
+				return { body: form };
+			}
+			let multipart;
+			try {
+				const filename = this.#filename(prepared, options);
+				const contentType = prepared.contentType ?? mimeFromFilename(filename);
+				if (options.validateMime !== false) assertAllowedMime(contentType, filename);
+				multipart = createMultipartFileBody({
+					stream: prepared.stream,
+					filename,
+					contentType: contentType ?? ""
+				});
+				return {
+					body: multipart.body,
+					headers: { "Content-Type": multipart.contentType },
+					cleanup: async () => {
+						await multipart?.cancel();
+						await prepared.close();
+					}
+				};
+			} catch (error) {
+				await prepared.close();
+				throw error;
+			}
+		};
 	}
-	/** Отмечает прочитанными все уведомления. */
-	async markAllRead(options = {}) {
-		const body = await this.http.operation("notifications.markAllRead", {
-			path: "/api/notifications/read-all",
+	/** Подбирает непустое имя, обязательное для multipart. */
+	#filename(source, options) {
+		if (options.filename) return options.filename;
+		if (source.filename) return source.filename;
+		const extension = options.contentType?.split(";", 1)[0]?.trim().split("/")[1];
+		return extension ? `file.${extension}` : "file";
+	}
+};
+//#endregion
+//#region src/resources/hashtags.ts
+const HASHTAG_POSTS = pageOperation("hashtags.posts", (body) => readCursorPage(body, "posts"));
+const HASHTAGS_SEARCH = require_url.defineBuiltInOperation("hashtags.search", (body) => require_url.pickArray(body, "hashtags"));
+const HASHTAGS_TRENDING = require_url.defineBuiltInOperation("hashtags.trending", (body) => require_url.pickArray(body, "hashtags"));
+/**
+* Хэштеги.
+*
+* Доступна как `itd.hashtags`.
+*/
+var HashtagsResource = class extends BaseResource {
+	/** Посты по хэштегу: `/api/hashtags/{tag}/posts`, курсорная пагинация. */
+	#posts = this.paginated({
+		operation: HASHTAG_POSTS,
+		path: (p) => `/api/hashtags/${require_redact.encodePathSegment(p.tag, "tag")}/posts`,
+		query: (p) => ({ limit: p.limit }),
+		start: (p) => p.cursor ? { cursor: p.cursor } : {},
+		mode: PaginationMode.Cursor
+	});
+	/**
+	* Ищет хэштеги.
+	*
+	* Без строки запроса возвращает общий список.
+	*/
+	search(query, params = {}, options = {}) {
+		return this.http.execute(HASHTAGS_SEARCH, {
+			path: "/api/hashtags",
+			query: {
+				q: query,
+				limit: params.limit
+			},
 			...options
 		});
-		return require_url.pickNumber(body, "markedCount", 0);
 	}
-	/** Загружает настройки уведомлений. */
-	async getSettings(options = {}) {
-		return readSettings(await this.http.operation("notifications.getSettings", {
-			path: "/api/notifications/settings",
+	/** Загружает трендовые хэштеги. */
+	trending(params = {}, options = {}) {
+		return this.http.execute(HASHTAGS_TRENDING, {
+			path: "/api/hashtags/trending",
+			query: { limit: params.limit },
 			...options
-		}));
+		});
 	}
 	/**
-	* Обновляет настройки уведомлений.
+	* Загружает страницу постов по хэштегу.
 	*
-	* Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
+	* @param tag название без решётки; кодируется автоматически, поэтому кириллица
+	* и пробелы допустимы
 	*/
-	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
-		}));
+	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/platform.ts
+const PLATFORM_CHANGELOG = require_url.defineBuiltInOperation("platform.changelog", (body) => Array.isArray(body) ? body : []);
+const PLATFORM_ANNOUNCEMENTS = require_url.defineBuiltInOperation("platform.announcements", (body) => require_url.pickArray(body, "announcements"));
+const PLATFORM_VERSION = require_url.passthroughOperation("platform.version");
+const PLATFORM_PORTAL = require_url.passthroughOperation("platform.portal");
 /**
 * Сведения о платформе: версии приложений, изменения, анонсы, баннер события.
 *
@@ -1606,31 +1908,29 @@ var PlatformResource = class extends BaseResource {
 	* ```
 	*/
 	version(options = {}) {
-		return this.http.operation("platform.version", {
+		return this.http.execute(PLATFORM_VERSION, {
 			path: "/api/platform/version",
 			skipAuth: true,
 			...options
 		});
 	}
 	/** Загружает журнал изменений. */
-	async changelog(options = {}) {
-		const body = await this.http.operation("platform.changelog", {
+	changelog(options = {}) {
+		return this.http.execute(PLATFORM_CHANGELOG, {
 			path: "/api/platform/changelog",
 			...options
 		});
-		return Array.isArray(body) ? body : [];
 	}
 	/** Загружает анонсы платформы. */
-	async announcements(options = {}) {
-		const body = await this.http.operation("platform.announcements", {
+	announcements(options = {}) {
+		return this.http.execute(PLATFORM_ANNOUNCEMENTS, {
 			path: "/api/platform/announcements",
 			...options
 		});
-		return require_url.pickArray(body, "announcements");
 	}
 	/** Загружает баннер текущего события — виджет «портал». */
 	portal(options = {}) {
-		return this.http.operation("platform.portal", {
+		return this.http.execute(PLATFORM_PORTAL, {
 			path: "/api/v1/portal",
 			...options
 		});
@@ -2347,7 +2647,7 @@ function autoSpans(text, options = {}) {
 		});
 	}
 	if (includeLinks) spans.push(...links);
-	if (includeHashtags || includeMentions) for (const match of text.matchAll(/#([\p{L}\p{M}\p{N}_]+)|@([a-z\d][a-z\d._-]*)/giu)) {
+	if (includeHashtags || includeMentions) for (const match of text.matchAll(/#([\p{L}\p{M}\p{N}_]+)|@([a-z\d](?:[a-z\d_]*[a-z\d])?)/giu)) {
 		if (match.index === void 0) continue;
 		const offset = match.index;
 		const previous = previousCodePoint(text, offset);
@@ -2355,7 +2655,7 @@ function autoSpans(text, options = {}) {
 		const end = offset + match[0].length;
 		if (links.some((span) => overlaps(span, offset, end))) continue;
 		const hashtag = match[1];
-		const username = match[2]?.replace(/[._-]+$/u, "");
+		const username = match[2];
 		if (hashtag !== void 0 && includeHashtags) spans.push({
 			type: require_url.SpanType.Hashtag,
 			offset,
@@ -2748,6 +3048,24 @@ function resolvePostUpdate(input) {
 }
 //#endregion
 //#region src/resources/posts.ts
+const POSTS_LIST = pageOperation("posts.list", (body) => readCursorPage(body, "posts"));
+const POSTS_BY_USER = pageOperation("posts.byUser", (body) => readCursorPage(body, "posts"));
+const POSTS_LIKED_BY_USER = pageOperation("posts.likedByUser", (body) => readCursorPage(body, "posts"));
+const POSTS_COMMENTS = pageOperation("posts.comments", (body) => readFlatCursorPage(body, "comments"));
+const POSTS_STATS = require_url.defineBuiltInOperation("posts.stats", (body) => require_url.pickArray(body, "posts"));
+const POSTS_CREATE = require_url.passthroughOperation("posts.create");
+const POSTS_GET = require_url.passthroughOperation("posts.get");
+const POSTS_UPDATE = require_url.passthroughOperation("posts.update");
+const POSTS_RESTORE = require_url.passthroughOperation("posts.restore");
+const POSTS_LIKE = require_url.passthroughOperation("posts.like");
+const POSTS_UNLIKE = require_url.passthroughOperation("posts.unlike");
+const POSTS_REPOST = require_url.passthroughOperation("posts.repost");
+const POSTS_PIN = require_url.passthroughOperation("posts.pin");
+const POSTS_UNPIN = require_url.passthroughOperation("posts.unpin");
+const POSTS_VOTE = require_url.passthroughOperation("posts.vote");
+const POSTS_COMMENT = require_url.passthroughOperation("posts.comment");
+const POSTS_REMOVE = require_url.voidOperation("posts.remove");
+const POSTS_UNREPOST = require_url.voidOperation("posts.unrepost");
 /** Курсорная позиция из параметров: если курсор задан — с него, иначе с начала. */
 function cursorStart(params) {
 	return params.cursor ? { cursor: params.cursor } : {};
@@ -2761,48 +3079,44 @@ var PostsResource = class extends BaseResource {
 	#uploadFiles;
 	/** Лента: `/api/posts`, курсорная пагинация. */
 	#feed = this.paginated({
-		operationId: "posts.list",
+		operation: POSTS_LIST,
 		path: () => "/api/posts",
 		query: (p) => ({
 			tab: p.tab,
 			limit: p.limit
 		}),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Стена пользователя: `/api/posts/user/{user}`. */
 	#wall = this.paginated({
-		operationId: "posts.byUser",
-		path: (p) => `/api/posts/user/${require_cookies.encodePathSegment(p.user, "user")}`,
+		operation: POSTS_BY_USER,
+		path: (p) => `/api/posts/user/${require_redact.encodePathSegment(p.user, "user")}`,
 		query: (p) => ({
 			limit: p.limit,
 			sort: p.sort,
 			pinnedPostId: p.pinnedPostId
 		}),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Понравившиеся посты пользователя: `/api/posts/user/{user}/liked`. */
 	#liked = this.paginated({
-		operationId: "posts.likedByUser",
-		path: (p) => `/api/posts/user/${require_cookies.encodePathSegment(p.user, "user")}/liked`,
+		operation: POSTS_LIKED_BY_USER,
+		path: (p) => `/api/posts/user/${require_redact.encodePathSegment(p.user, "user")}/liked`,
 		query: (p) => ({ limit: p.limit }),
 		start: cursorStart,
-		read: (body) => readCursorPage(body, "posts"),
 		mode: PaginationMode.Cursor
 	});
 	/** Комментарии к посту: курсор лежит рядом со списком, поэтому свой reader. */
 	#comments = this.paginated({
-		operationId: "posts.comments",
-		path: (p) => `/api/posts/${require_cookies.encodePathSegment(p.postId, "postId")}/comments`,
+		operation: POSTS_COMMENTS,
+		path: (p) => `/api/posts/${require_redact.encodePathSegment(p.postId, "postId")}/comments`,
 		query: (p) => ({
 			limit: p.limit,
 			sort: p.sort
 		}),
 		start: cursorStart,
-		read: (body) => readFlatCursorPage(body, "comments"),
 		mode: PaginationMode.Cursor
 	});
 	constructor(http, deps) {
@@ -2849,7 +3163,7 @@ var PostsResource = class extends BaseResource {
 	async create(input, options = {}) {
 		const data = resolvePost(input);
 		const attachmentIds = await this.#collectAttachments(data, options);
-		return this.http.operation("posts.create", {
+		return this.http.execute(POSTS_CREATE, {
 			path: "/api/posts",
 			body: {
 				content: data.content ?? "",
@@ -2867,8 +3181,8 @@ var PostsResource = class extends BaseResource {
 	* В отличие от списков, здесь у поста заполнено поле `comments`.
 	*/
 	get(postId, options = {}) {
-		return this.http.operation("posts.get", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.http.execute(POSTS_GET, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			...options
 		});
 	}
@@ -2881,8 +3195,8 @@ var PostsResource = class extends BaseResource {
 	*/
 	update(postId, input, options = {}) {
 		const data = resolvePostUpdate(input);
-		return this.http.operation("posts.update", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.http.execute(POSTS_UPDATE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			body: {
 				content: data.content,
 				...data.spans ? { spans: data.spans } : {}
@@ -2892,29 +3206,29 @@ var PostsResource = class extends BaseResource {
 	}
 	/** Удаляет пост. Восстановить его можно через {@link restore}. */
 	remove(postId, options = {}) {
-		return this.http.operation("posts.remove", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}`,
+		return this.voidOperation(POSTS_REMOVE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}`,
 			...options
 		});
 	}
 	/** Восстанавливает удалённый пост. */
 	restore(postId, options = {}) {
-		return this.http.operation("posts.restore", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/restore`,
+		return this.http.execute(POSTS_RESTORE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/restore`,
 			...options
 		});
 	}
 	/** Ставит реакцию на пост. */
 	like(postId, options = {}) {
-		return this.http.operation("posts.like", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/like`,
+		return this.http.execute(POSTS_LIKE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
 	}
 	/** Убирает реакцию с поста. */
 	unlike(postId, options = {}) {
-		return this.http.operation("posts.unlike", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/like`,
+		return this.http.execute(POSTS_UNLIKE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/like`,
 			...options
 		});
 	}
@@ -2925,30 +3239,30 @@ var PostsResource = class extends BaseResource {
 	* для файлов здесь нет.
 	*/
 	repost(postId, content = "", options = {}) {
-		return this.http.operation("posts.repost", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/repost`,
+		return this.http.execute(POSTS_REPOST, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/repost`,
 			body: { content },
 			...options
 		});
 	}
 	/** Отменяет репост. */
 	unrepost(postId, options = {}) {
-		return this.http.operation("posts.unrepost", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/repost`,
+		return this.voidOperation(POSTS_UNREPOST, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/repost`,
 			...options
 		});
 	}
 	/** Закрепляет пост в профиле. */
 	pin(postId, options = {}) {
-		return this.http.operation("posts.pin", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/pin`,
+		return this.http.execute(POSTS_PIN, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/pin`,
 			...options
 		});
 	}
 	/** Открепляет пост. */
 	unpin(postId, options = {}) {
-		return this.http.operation("posts.unpin", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/pin`,
+		return this.http.execute(POSTS_UNPIN, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/pin`,
 			...options
 		});
 	}
@@ -2958,20 +3272,19 @@ var PostsResource = class extends BaseResource {
 	* @param optionIds выбранные варианты; несколько допустимы только при `multipleChoice`
 	*/
 	vote(postId, optionIds, options = {}) {
-		return this.http.operation("posts.vote", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/poll/vote`,
+		return this.http.execute(POSTS_VOTE, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/poll/vote`,
 			body: { optionIds },
 			...options
 		});
 	}
 	/** Запрашивает счётчики сразу для нескольких постов. */
-	async stats(ids, options = {}) {
-		const body = await this.http.operation("posts.stats", {
+	stats(ids, options = {}) {
+		return this.http.execute(POSTS_STATS, {
 			path: "/api/posts/stats",
 			body: { ids },
 			...options
 		});
-		return require_url.pickArray(body, "posts");
 	}
 	/**
 	* Загружает страницу стены пользователя.
@@ -3041,8 +3354,8 @@ var PostsResource = class extends BaseResource {
 	async comment(postId, input, options = {}) {
 		const data = resolveComment(typeof input === "string" ? { content: input } : input);
 		const attachmentIds = await this.#collectAttachments(data, options);
-		return this.http.operation("posts.comment", {
-			path: `/api/posts/${require_cookies.encodePathSegment(postId, "postId")}/comments`,
+		return this.http.execute(POSTS_COMMENT, {
+			path: `/api/posts/${require_redact.encodePathSegment(postId, "postId")}/comments`,
 			body: {
 				content: data.content ?? "",
 				attachmentIds
@@ -3162,6 +3475,7 @@ function resolveReport(input) {
 }
 //#endregion
 //#region src/resources/reports.ts
+const REPORTS_CREATE = require_url.passthroughOperation("reports.create");
 /**
 * Жалобы на контент и пользователей.
 *
@@ -3182,7 +3496,7 @@ var ReportsResource = class extends BaseResource {
 	*/
 	create(input, options = {}) {
 		const data = resolveReport(input);
-		return this.http.operation("reports.create", {
+		return this.http.execute(REPORTS_CREATE, {
 			path: "/api/reports",
 			body: data,
 			...options
@@ -3191,6 +3505,10 @@ var ReportsResource = class extends BaseResource {
 };
 //#endregion
 //#region src/resources/search.ts
+const SEARCH_ALL = require_url.defineBuiltInOperation("search.all", (body) => ({
+	users: require_url.pickArray(body, "users"),
+	hashtags: require_url.pickArray(body, "hashtags")
+}));
 /**
 * Глобальный поиск.
 *
@@ -3205,20 +3523,212 @@ var SearchResource = class extends BaseResource {
 	* const { users, hashtags } = await itd.search.all('арт');
 	* ```
 	*/
-	async all(query, options = {}) {
-		const body = await this.http.operation("search.all", {
+	all(query, options = {}) {
+		return this.http.execute(SEARCH_ALL, {
 			path: "/api/search",
 			query: { q: query },
 			...options
 		});
-		return {
-			users: require_url.pickArray(body, "users"),
-			hashtags: require_url.pickArray(body, "hashtags")
-		};
+	}
+};
+//#endregion
+//#region src/resources/shop.ts
+const PRODUCTS_LIST = require_url.passthroughOperation("shop.products.list");
+const PRODUCTS_GET = require_url.passthroughOperation("shop.products.get");
+const DELIVERY_COUNTRIES = require_url.passthroughOperation("shop.delivery.countries");
+const DELIVERY_CITIES = require_url.passthroughOperation("shop.delivery.cities");
+const DELIVERY_POINTS = require_url.passthroughOperation("shop.delivery.points");
+const DELIVERY_CALCULATE = require_url.passthroughOperation("shop.delivery.calculate");
+const ORDERS_CREATE = require_url.passthroughOperation("shop.orders.create");
+const ORDERS_LIST = require_url.passthroughOperation("shop.orders.list");
+const ORDERS_GET = require_url.passthroughOperation("shop.orders.get");
+const ORDERS_PAY = require_url.passthroughOperation("shop.orders.pay");
+const ORDERS_REQUEST_ACCESS_CODE = require_url.voidOperation("shop.orders.requestAccessCode");
+const ORDERS_VERIFY_ACCESS_CODE = require_url.passthroughOperation("shop.orders.verifyAccessCode");
+const CONSENTS_RECORD = require_url.voidOperation("shop.consents.record");
+function orderRequestOptions(options) {
+	const { orderAccessToken, useItdAuth, headers, ...request } = options;
+	return {
+		...request,
+		...useItdAuth === false ? { skipAuth: true } : {},
+		headers: {
+			...headers,
+			...orderAccessToken ? { "X-Order-Token": orderAccessToken } : {}
+		}
+	};
+}
+/** Каталог товаров магазина. */
+var ShopProductsResource = class extends BaseResource {
+	/** Загружает все товары. */
+	list(options = {}) {
+		return this.http.execute(PRODUCTS_LIST, {
+			path: "/api/v1/shop/products",
+			raw: true,
+			...options
+		});
+	}
+	/** Загружает товар по идентификатору. */
+	async get(productId, options = {}) {
+		try {
+			return await this.http.execute(PRODUCTS_GET, {
+				path: `/api/v1/shop/products/${require_redact.encodePathSegment(productId, "идентификатор товара")}`,
+				raw: true,
+				...options
+			});
+		} catch (error) {
+			if (require_errors.isItdApiError(error) && error.status === 404) return null;
+			throw error;
+		}
+	}
+};
+/** Расчёт и выбор доставки. */
+var ShopDeliveryResource = class extends BaseResource {
+	/** Загружает страны, в которые доступна доставка. */
+	countries(options = {}) {
+		return this.http.execute(DELIVERY_COUNTRIES, {
+			path: "/api/v1/shop/delivery/countries",
+			raw: true,
+			...options
+		});
+	}
+	/** Ищет города службы доставки. */
+	cities(query, countryCode, options = {}) {
+		return this.http.execute(DELIVERY_CITIES, {
+			path: "/api/v1/shop/delivery/cities",
+			query: {
+				q: query,
+				country: countryCode
+			},
+			raw: true,
+			...options
+		});
+	}
+	/** Загружает пункты выдачи в городе. */
+	points(cityCode, options = {}) {
+		return this.http.execute(DELIVERY_POINTS, {
+			path: "/api/v1/shop/delivery/points",
+			query: { cityCode },
+			raw: true,
+			...options
+		});
+	}
+	/** Рассчитывает стоимость и срок доставки. */
+	calculate(items, destination, options = {}) {
+		return this.http.execute(DELIVERY_CALCULATE, {
+			path: "/api/v1/shop/delivery/calculate",
+			body: {
+				items,
+				to: destination
+			},
+			raw: true,
+			...options
+		});
+	}
+};
+/** Создание, просмотр и оплата заказов. */
+var ShopOrdersResource = class extends BaseResource {
+	/** Создаёт заказ. */
+	create(input, options = {}) {
+		const { idempotencyKey = require_redact.createDeviceId(), headers, ...request } = options;
+		return this.http.execute(ORDERS_CREATE, {
+			path: "/api/v1/shop/orders",
+			body: input,
+			headers: {
+				...headers,
+				"Idempotency-Key": idempotencyKey
+			},
+			raw: true,
+			...request
+		});
+	}
+	/** Загружает заказы аккаунта ИТД или владельца временного токена. */
+	list(options = {}) {
+		return this.http.execute(ORDERS_LIST, {
+			path: "/api/v1/shop/orders/my",
+			raw: true,
+			...orderRequestOptions(options)
+		});
+	}
+	/** Загружает заказ по номеру. */
+	get(orderNumber, options = {}) {
+		return this.http.execute(ORDERS_GET, {
+			path: `/api/v1/shop/orders/${require_redact.encodePathSegment(orderNumber, "номер заказа")}`,
+			raw: true,
+			...orderRequestOptions(options)
+		});
+	}
+	/** Создаёт ссылку на оплату заказа. */
+	pay(orderNumber, options) {
+		const { returnUrl, ...access } = options;
+		return this.http.execute(ORDERS_PAY, {
+			path: `/api/v1/shop/orders/${require_redact.encodePathSegment(orderNumber, "номер заказа")}/pay`,
+			body: { returnUrl },
+			raw: true,
+			...orderRequestOptions(access)
+		});
+	}
+	/** Отправляет на почту код доступа к гостевым заказам. */
+	requestAccessCode(email, options = {}) {
+		return this.http.execute(ORDERS_REQUEST_ACCESS_CODE, {
+			path: "/api/v1/shop/orders/lookup/request",
+			body: { email },
+			raw: true,
+			skipAuth: true,
+			...options
+		});
+	}
+	/** Проверяет код из письма и возвращает временный токен заказов. */
+	verifyAccessCode(email, code, options = {}) {
+		return this.http.execute(ORDERS_VERIFY_ACCESS_CODE, {
+			path: "/api/v1/shop/orders/lookup/verify",
+			body: {
+				email,
+				code
+			},
+			raw: true,
+			skipAuth: true,
+			...options
+		});
+	}
+};
+/** Запись согласий магазина. */
+var ShopConsentsResource = class extends BaseResource {
+	/** Записывает согласия покупателя. */
+	record(consents, consentContext, options = {}) {
+		return this.http.execute(CONSENTS_RECORD, {
+			path: "/api/v1/shop/consents",
+			body: {
+				consents,
+				consentContext
+			},
+			raw: true,
+			...options
+		});
+	}
+};
+/** Магазин ИТД. */
+var ShopResource = class {
+	products;
+	delivery;
+	orders;
+	consents;
+	/** @internal */
+	constructor(http) {
+		this.products = new ShopProductsResource(http);
+		this.delivery = new ShopDeliveryResource(http);
+		this.orders = new ShopOrdersResource(http);
+		this.consents = new ShopConsentsResource(http);
 	}
 };
 //#endregion
 //#region src/resources/subscription.ts
+const SUBSCRIPTION_METHODS = require_url.defineBuiltInOperation("subscription.methods", (body) => Array.isArray(body) ? body : []);
+const SUBSCRIPTION_STATUS = require_url.passthroughOperation("subscription.status");
+const SUBSCRIPTION_PAY = require_url.passthroughOperation("subscription.pay");
+const SUBSCRIPTION_SET_AUTO_RENEWAL = require_url.passthroughOperation("subscription.setAutoRenewal");
+const SUBSCRIPTION_BIND_CARD = require_url.passthroughOperation("subscription.bindCard");
+const SUBSCRIPTION_SET_DEFAULT_METHOD = require_url.passthroughOperation("subscription.setDefaultMethod");
+const SUBSCRIPTION_REMOVE_METHOD = require_url.voidOperation("subscription.removeMethod");
 /**
 * Подписка и способы оплаты.
 *
@@ -3227,7 +3737,7 @@ var SearchResource = class extends BaseResource {
 var SubscriptionResource = class extends BaseResource {
 	/** Загружает состояние подписки и её цену. */
 	status(options = {}) {
-		return this.http.operation("subscription.status", {
+		return this.http.execute(SUBSCRIPTION_STATUS, {
 			path: "/api/v1/subscription/",
 			...options
 		});
@@ -3238,14 +3748,14 @@ var SubscriptionResource = class extends BaseResource {
 	* Форма ответа в документации API не описана, поэтому тип результата не уточняется.
 	*/
 	pay(options = {}) {
-		return this.http.operation("subscription.pay", {
+		return this.http.execute(SUBSCRIPTION_PAY, {
 			path: "/api/v1/subscription/pay",
 			...options
 		});
 	}
 	/** Включает или отключает автопродление. */
 	setAutoRenewal(enabled, options = {}) {
-		return this.http.operation("subscription.setAutoRenewal", {
+		return this.http.execute(SUBSCRIPTION_SET_AUTO_RENEWAL, {
 			path: "/api/v1/subscription/auto-renewal",
 			body: { enabled },
 			...options
@@ -3253,30 +3763,29 @@ var SubscriptionResource = class extends BaseResource {
 	}
 	/** Запускает привязку карты. */
 	bindCard(options = {}) {
-		return this.http.operation("subscription.bindCard", {
+		return this.http.execute(SUBSCRIPTION_BIND_CARD, {
 			path: "/api/v1/subscription/bind-card",
 			...options
 		});
 	}
 	/** Загружает список способов оплаты. Пустой массив, если карт нет. */
-	async methods(options = {}) {
-		const body = await this.http.operation("subscription.methods", {
+	methods(options = {}) {
+		return this.http.execute(SUBSCRIPTION_METHODS, {
 			path: "/api/v1/subscription/methods",
 			...options
 		});
-		return Array.isArray(body) ? body : [];
 	}
 	/** Делает способ оплаты основным. */
 	setDefaultMethod(methodId, options = {}) {
-		return this.http.operation("subscription.setDefaultMethod", {
-			path: `/api/v1/subscription/methods/${require_cookies.encodePathSegment(methodId, "methodId")}/default`,
+		return this.http.execute(SUBSCRIPTION_SET_DEFAULT_METHOD, {
+			path: `/api/v1/subscription/methods/${require_redact.encodePathSegment(methodId, "methodId")}/default`,
 			...options
 		});
 	}
 	/** Удаляет способ оплаты. */
 	removeMethod(methodId, options = {}) {
-		return this.http.operation("subscription.removeMethod", {
-			path: `/api/v1/subscription/methods/${require_cookies.encodePathSegment(methodId, "methodId")}`,
+		return this.voidOperation(SUBSCRIPTION_REMOVE_METHOD, {
+			path: `/api/v1/subscription/methods/${require_redact.encodePathSegment(methodId, "methodId")}`,
 			...options
 		});
 	}
@@ -3434,7 +3943,7 @@ var TelemetryBatchImpl = class {
 	close() {
 		return this.#close(false);
 	}
-	/** Внутренняя финализация после перехода клиента в terminal state. */
+	/** Внутренняя отправка данных после вызова `dispose()`. */
 	closeForDispose() {
 		this.prepareForDispose();
 		return this.#close(true);
@@ -3504,7 +4013,7 @@ var TelemetryResource = class extends BaseResource {
 	}
 	/** Идентификатор сессии телеметрии, общий для всех событий этого ресурса. */
 	get sessionId() {
-		this.#sessionId ??= require_url.createDeviceId();
+		this.#sessionId ??= require_redact.createDeviceId();
 		return this.#sessionId;
 	}
 	/** Отправляет события просмотра постов (`POST /api/v1/i`). */
@@ -3530,7 +4039,7 @@ var TelemetryResource = class extends BaseResource {
 			},
 			...requestOptions
 		};
-		return disposeCleanup ? this.http.cleanupOperation("telemetry.dwell", options) : this.http.operation("telemetry.dwell", options);
+		return disposeCleanup ? this.http.cleanupOperation(TELEMETRY_DWELL, options) : this.http.execute(TELEMETRY_DWELL, options);
 	}
 	/** Отправляет события взаимодействия с контентом (`POST /api/v1/x`). */
 	interaction(entries, telemetryOptions = {}, requestOptions = {}) {
@@ -3554,7 +4063,7 @@ var TelemetryResource = class extends BaseResource {
 			},
 			...requestOptions
 		};
-		return disposeCleanup ? this.http.cleanupOperation("telemetry.interaction", options) : this.http.operation("telemetry.interaction", options);
+		return disposeCleanup ? this.http.cleanupOperation(TELEMETRY_INTERACTION, options) : this.http.execute(TELEMETRY_INTERACTION, options);
 	}
 	/** Начинает измерять время просмотра и отправляет результат после `finish()`. */
 	startView(input, options = {}, requestOptions = {}) {
@@ -3597,12 +4106,43 @@ var TelemetryResource = class extends BaseResource {
 function prepareTelemetryForDispose(resource) {
 	if (resource) TELEMETRY_DISPOSE_PREPARERS.get(resource)?.();
 }
-/** Финализирует созданные накопители после перехода клиента в terminal state. @internal */
+/** Отправляет и закрывает созданные накопители после вызова `dispose()`. @internal */
 function closeTelemetryForDispose(resource) {
 	return resource ? TELEMETRY_DISPOSE_CLOSERS.get(resource)?.() ?? Promise.resolve() : Promise.resolve();
 }
+const TELEMETRY_DWELL = require_url.defineBuiltInOperation("telemetry.dwell");
+const TELEMETRY_INTERACTION = require_url.defineBuiltInOperation("telemetry.interaction");
 //#endregion
 //#region src/resources/users.ts
+const userListOperation = (id) => pageOperation(id, (body) => readPagedPage(body, "users", "followers", "following", "blocked"));
+const USER_LIST_OPERATIONS = {
+	"users.followers": userListOperation("users.followers"),
+	"users.following": userListOperation("users.following"),
+	"users.blocked": userListOperation("users.blocked")
+};
+const USERS_CHECK_USERNAME = require_url.defineBuiltInOperation("users.checkUsername", (body) => require_url.pickBoolean(body, "available"));
+const USERS_SEARCH = require_url.defineBuiltInOperation("users.search", (body) => require_url.pickArray(body, "users"));
+const USERS_WHO_TO_FOLLOW = require_url.defineBuiltInOperation("users.whoToFollow", (body) => require_url.pickArray(body, "users"));
+const USERS_TOP_CLANS = require_url.defineBuiltInOperation("users.topClans", (body) => require_url.pickArray(body, "clans"));
+const USERS_PINS = require_url.defineBuiltInOperation("users.pins", (body) => ({
+	pins: require_url.pickArray(body, "pins"),
+	activePin: require_url.pickString(body, "activePin") ?? null
+}));
+const USERS_ME = require_url.passthroughOperation("users.me");
+const USERS_UPDATE_ME = require_url.passthroughOperation("users.updateMe");
+const USERS_CREATE_PROFILE = require_url.passthroughOperation("users.createProfile");
+const USERS_GET = require_url.passthroughOperation("users.get");
+const USERS_FOLLOW = require_url.passthroughOperation("users.follow");
+const USERS_FOLLOW_STATUS = require_url.passthroughOperation("users.followStatus");
+const USERS_GET_PRIVACY = require_url.passthroughOperation("users.getPrivacy");
+const USERS_UPDATE_PRIVACY = require_url.passthroughOperation("users.updatePrivacy");
+const USERS_DEACTIVATE = require_url.voidOperation("users.deactivate");
+const USERS_RESTORE = require_url.voidOperation("users.restore");
+const USERS_UNFOLLOW = require_url.voidOperation("users.unfollow");
+const USERS_BLOCK = require_url.voidOperation("users.block");
+const USERS_UNBLOCK = require_url.voidOperation("users.unblock");
+const USERS_SET_PIN = require_url.voidOperation("users.setPin");
+const USERS_REMOVE_PIN = require_url.voidOperation("users.removePin");
 /**
 * Пользователи: профили, подписки, блокировки, приватность.
 *
@@ -3623,23 +4163,22 @@ var UsersResource = class extends BaseResource {
 	* сервер его сейчас не читает (см. {@link followers}): когда починят — заработает само.
 	*/
 	#userList = this.paginated({
-		operationId: (p) => p.operationId,
+		operation: (p) => p.operation,
 		path: (p) => p.path,
 		query: (p) => ({ limit: p.limit }),
 		start: (p) => p.page !== void 0 ? { page: p.page } : {},
-		read: (body) => readPagedPage(body, "users", "followers", "following", "blocked"),
 		mode: PaginationMode.Page
 	});
 	/** Загружает свой профиль — с подпиской и признаком подтверждённого телефона. */
 	me(options = {}) {
-		return this.http.operation("users.me", {
+		return this.http.execute(USERS_ME, {
 			path: "/api/users/me",
 			...options
 		});
 	}
 	/** Обновляет свой профиль. Передавайте только изменяемые поля. */
 	updateMe(input, options = {}) {
-		return this.http.operation("users.updateMe", {
+		return this.http.execute(USERS_UPDATE_ME, {
 			path: "/api/users/me",
 			body: input,
 			...options
@@ -3666,21 +4205,21 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Деактивирует аккаунт. Вернуть его можно через {@link restore}. */
 	deactivate(options = {}) {
-		return this.http.operation("users.deactivate", {
+		return this.voidOperation(USERS_DEACTIVATE, {
 			path: "/api/users/me",
 			...options
 		});
 	}
 	/** Восстанавливает деактивированный аккаунт. */
 	restore(options = {}) {
-		return this.http.operation("users.restore", {
+		return this.voidOperation(USERS_RESTORE, {
 			path: "/api/users/me/restore",
 			...options
 		});
 	}
 	/** Создаёт профиль после регистрации. */
 	createProfile(input, options = {}) {
-		return this.http.operation("users.createProfile", {
+		return this.http.execute(USERS_CREATE_PROFILE, {
 			path: "/api/users/profile",
 			body: input,
 			...options
@@ -3698,23 +4237,22 @@ var UsersResource = class extends BaseResource {
 	* ```
 	*/
 	get(user, options = {}) {
-		return this.http.operation("users.get", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}`,
+		return this.http.execute(USERS_GET, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}`,
 			...options
 		});
 	}
 	/** Проверяет, свободно ли имя пользователя. */
-	async checkUsername(username, options = {}) {
-		const body = await this.http.operation("users.checkUsername", {
+	checkUsername(username, options = {}) {
+		return this.http.execute(USERS_CHECK_USERNAME, {
 			path: "/api/users/check-username",
 			query: { username },
 			...options
 		});
-		return require_url.pickBoolean(body, "available");
 	}
 	/** Ищет пользователей по строке запроса. */
-	async search(query, params = {}, options = {}) {
-		const body = await this.http.operation("users.search", {
+	search(query, params = {}, options = {}) {
+		return this.http.execute(USERS_SEARCH, {
 			path: "/api/users/search",
 			query: {
 				q: query,
@@ -3722,23 +4260,20 @@ var UsersResource = class extends BaseResource {
 			},
 			...options
 		});
-		return require_url.pickArray(body, "users");
 	}
 	/** Загружает рекомендации, на кого подписаться. */
-	async whoToFollow(options = {}) {
-		const body = await this.http.operation("users.whoToFollow", {
+	whoToFollow(options = {}) {
+		return this.http.execute(USERS_WHO_TO_FOLLOW, {
 			path: "/api/users/suggestions/who-to-follow",
 			...options
 		});
-		return require_url.pickArray(body, "users");
 	}
 	/** Загружает рейтинг кланов. */
-	async topClans(options = {}) {
-		const body = await this.http.operation("users.topClans", {
+	topClans(options = {}) {
+		return this.http.execute(USERS_TOP_CLANS, {
 			path: "/api/users/stats/top-clans",
 			...options
 		});
-		return require_url.pickArray(body, "clans");
 	}
 	/**
 	* Подписывается на пользователя.
@@ -3746,16 +4281,16 @@ var UsersResource = class extends BaseResource {
 	* У закрытого профиля вместо подписки отправляется заявка — это видно по полю `status`.
 	*/
 	follow(user, options = {}) {
-		return this.http.operation("users.follow", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/follow`,
+		return this.http.execute(USERS_FOLLOW, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/follow`,
 			body: {},
 			...options
 		});
 	}
 	/** Отписывается от пользователя. */
 	unfollow(user, options = {}) {
-		return this.http.operation("users.unfollow", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/follow`,
+		return this.voidOperation(USERS_UNFOLLOW, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/follow`,
 			...options
 		});
 	}
@@ -3771,7 +4306,7 @@ var UsersResource = class extends BaseResource {
 	* на проверенных аккаунтах занижено примерно на 1–4%.
 	*/
 	followers(user, params = {}, options = {}) {
-		return this.#userPage("users.followers", `/api/users/${require_cookies.encodePathSegment(user, "user")}/followers`, params, options);
+		return this.#userPage("users.followers", `/api/users/${require_redact.encodePathSegment(user, "user")}/followers`, params, options);
 	}
 	/**
 	* Перебирает подписчиков.
@@ -3780,15 +4315,15 @@ var UsersResource = class extends BaseResource {
 	* см. {@link followers}. Метод оставлен на случай, если пагинацию починят.
 	*/
 	iterateFollowers(user, params = {}, options = {}) {
-		return this.#userPaginator("users.followers", `/api/users/${require_cookies.encodePathSegment(user, "user")}/followers`, params, options);
+		return this.#userPaginator("users.followers", `/api/users/${require_redact.encodePathSegment(user, "user")}/followers`, params, options);
 	}
 	/** Загружает подписки пользователя. Ограничения те же, что у {@link followers}. */
 	following(user, params = {}, options = {}) {
-		return this.#userPage("users.following", `/api/users/${require_cookies.encodePathSegment(user, "user")}/following`, params, options);
+		return this.#userPage("users.following", `/api/users/${require_redact.encodePathSegment(user, "user")}/following`, params, options);
 	}
 	/** Перебирает подписки. Закончится после первых 20 записей — см. {@link followers}. */
 	iterateFollowing(user, params = {}, options = {}) {
-		return this.#userPaginator("users.following", `/api/users/${require_cookies.encodePathSegment(user, "user")}/following`, params, options);
+		return this.#userPaginator("users.following", `/api/users/${require_redact.encodePathSegment(user, "user")}/following`, params, options);
 	}
 	/**
 	* Проверяет, подписаны ли вы, сразу для нескольких пользователей.
@@ -3802,7 +4337,7 @@ var UsersResource = class extends BaseResource {
 	* ```
 	*/
 	followStatus(userIds, options = {}) {
-		return this.http.operation("users.followStatus", {
+		return this.http.execute(USERS_FOLLOW_STATUS, {
 			path: "/api/users/follow-status",
 			body: { userIds },
 			...options
@@ -3810,16 +4345,16 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Блокирует пользователя. */
 	block(user, options = {}) {
-		return this.http.operation("users.block", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/block`,
+		return this.voidOperation(USERS_BLOCK, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/block`,
 			body: {},
 			...options
 		});
 	}
 	/** Снимает блокировку. */
 	unblock(user, options = {}) {
-		return this.http.operation("users.unblock", {
-			path: `/api/users/${require_cookies.encodePathSegment(user, "user")}/block`,
+		return this.voidOperation(USERS_UNBLOCK, {
+			path: `/api/users/${require_redact.encodePathSegment(user, "user")}/block`,
 			...options
 		});
 	}
@@ -3833,14 +4368,14 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Загружает настройки приватности. */
 	getPrivacy(options = {}) {
-		return this.http.operation("users.getPrivacy", {
+		return this.http.execute(USERS_GET_PRIVACY, {
 			path: "/api/users/me/privacy",
 			...options
 		});
 	}
 	/** Обновляет настройки приватности. Передавайте только изменяемые поля. */
 	updatePrivacy(input, options = {}) {
-		return this.http.operation("users.updatePrivacy", {
+		return this.http.execute(USERS_UPDATE_PRIVACY, {
 			path: "/api/users/me/privacy",
 			body: input,
 			...options
@@ -3851,19 +4386,15 @@ var UsersResource = class extends BaseResource {
 	*
 	* `activePin` — строка-идентификатор, а не объект.
 	*/
-	async pins(options = {}) {
-		const body = await this.http.operation("users.pins", {
+	pins(options = {}) {
+		return this.http.execute(USERS_PINS, {
 			path: "/api/users/me/pins",
 			...options
 		});
-		return {
-			pins: require_url.pickArray(body, "pins"),
-			activePin: require_url.pickString(body, "activePin") ?? null
-		};
 	}
 	/** Выбирает активный значок профиля. */
 	setPin(slug, options = {}) {
-		return this.http.operation("users.setPin", {
+		return this.voidOperation(USERS_SET_PIN, {
 			path: "/api/users/me/pin",
 			body: { slug },
 			...options
@@ -3871,7 +4402,7 @@ var UsersResource = class extends BaseResource {
 	}
 	/** Снимает активный значок. */
 	removePin(options = {}) {
-		return this.http.operation("users.removePin", {
+		return this.voidOperation(USERS_REMOVE_PIN, {
 			path: "/api/users/me/pin",
 			...options
 		});
@@ -3879,20 +4410,22 @@ var UsersResource = class extends BaseResource {
 	#userPage(operationId, path, params, options) {
 		return this.#userList.list({
 			...params,
-			operationId,
+			operation: USER_LIST_OPERATIONS[operationId],
 			path
 		}, options);
 	}
 	#userPaginator(operationId, path, params, options) {
 		return this.#userList.iterate({
 			...params,
-			operationId,
+			operation: USER_LIST_OPERATIONS[operationId],
 			path
 		}, options);
 	}
 };
 //#endregion
 //#region src/resources/verification.ts
+const VERIFICATION_STATUS = require_url.passthroughOperation("verification.status");
+const VERIFICATION_SUBMIT = require_url.passthroughOperation("verification.submit");
 /**
 * Верификация профиля.
 *
@@ -3901,14 +4434,14 @@ var UsersResource = class extends BaseResource {
 var VerificationResource = class extends BaseResource {
 	/** Загружает статус заявки. Значение `none` означает, что заявка не подавалась. */
 	status(options = {}) {
-		return this.http.operation("verification.status", {
+		return this.http.execute(VERIFICATION_STATUS, {
 			path: "/api/verification/status",
 			...options
 		});
 	}
 	/** Подаёт заявку на верификацию с видео. */
 	submit(videoUrl, options = {}) {
-		return this.http.operation("verification.submit", {
+		return this.http.execute(VERIFICATION_SUBMIT, {
 			path: "/api/verification/submit",
 			body: { videoUrl },
 			...options
@@ -3939,6 +4472,7 @@ function createResources(deps) {
 	let subscription;
 	let platform;
 	let telemetry;
+	let shop;
 	const bag = {
 		get users() {
 			users ??= new UsersResource(deps.http, { uploadFile });
@@ -3953,11 +4487,11 @@ function createResources(deps) {
 			return comments;
 		},
 		get files() {
-			files ??= new FilesResource(deps.http, { fetch: deps.fetch });
+			files ??= new FilesResource(deps.http, { files: deps.files });
 			return files;
 		},
 		get notifications() {
-			notifications ??= new NotificationsResource(deps.http);
+			notifications ??= deps.createNotifications(deps.http);
 			return notifications;
 		},
 		get hashtags() {
@@ -3988,6 +4522,10 @@ function createResources(deps) {
 			telemetry ??= new TelemetryResource(deps.http);
 			return telemetry;
 		},
+		get shop() {
+			shop ??= new ShopResource(deps.http);
+			return shop;
+		},
 		closeTelemetry: (forDispose) => forDispose ? closeTelemetryForDispose(telemetry) : telemetry?.close() ?? Promise.resolve(),
 		prepareTelemetryClose: () => prepareTelemetryForDispose(telemetry)
 	};
@@ -4021,7 +4559,7 @@ function fromStream(factory, options = {}) {
 			throw new require_errors.ItdFileError("не удалось открыть поток вложения", {
 				reason: require_errors.ItdFileErrorReason.Read,
 				retryable: true,
-				cause: error
+				cause: require_redact.redactErrorCause(error)
 			});
 		}
 		const content = require_options.isReadableByteStream(opened) ? { stream: opened } : opened;
@@ -4061,6 +4599,36 @@ function isMyProfile(profile) {
 	return "subscription" in profile;
 }
 //#endregion
+//#region src/models/shop.ts
+/** Категория товара магазина. */
+const ShopProductCategory = Object.freeze({
+	Apparel: "apparel",
+	Accessories: "accessories",
+	Print: "print"
+});
+/** Состояние товара в каталоге. */
+const ShopProductStatus = Object.freeze({
+	Available: "available",
+	Preorder: "preorder",
+	SoldOut: "soldout"
+});
+/** Вид согласия, которое принимает покупатель. */
+const ShopConsentKind = Object.freeze({
+	Offer: "offer",
+	PersonalData: "personal_data",
+	Cookie: "cookie"
+});
+/** Состояние заказа. */
+const ShopOrderStatus = Object.freeze({
+	New: "new",
+	Paid: "paid",
+	Shipping: "ship",
+	Done: "done",
+	Cancelled: "cancelled",
+	Refunded: "refunded",
+	Expired: "expired"
+});
+//#endregion
 //#region src/models/status-helpers.ts
 const STATUS_WINDOW_DAYS = 90;
 /**
@@ -4082,6 +4650,186 @@ function statusDays(service) {
 	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
 }
 //#endregion
+//#region src/shop/order-access.ts
+function copySession(session) {
+	return { ...session };
+}
+/** Хранилище доступа к заказам в памяти процесса. */
+var MemoryShopOrderAccessStorage = class {
+	#session;
+	constructor(initial = null) {
+		this.#session = initial ? copySession(initial) : null;
+	}
+	get() {
+		return this.#session ? copySession(this.#session) : null;
+	}
+	set(session) {
+		this.#session = copySession(session);
+	}
+	clear() {
+		this.#session = null;
+	}
+};
+/** Создаёт хранилище доступа к заказам поверх `KeyValueStore`. */
+function createShopOrderAccessStorage(store, options = {}) {
+	const key = options.key ?? "shop-order-access";
+	if (typeof key !== "string" || key.length === 0) throw new require_errors.ItdConfigError("ключ хранилища доступа к заказам должен быть непустой строкой");
+	const backend = require_key_value_store.createKeyValueStore(store);
+	return {
+		async get() {
+			const session = await backend.get(key);
+			return session ? copySession(session) : null;
+		},
+		set: (session) => backend.set(key, copySession(session)),
+		clear: () => backend.delete(key)
+	};
+}
+/** Создаёт независимое хранилище доступа к заказам в памяти. */
+function createMemoryShopOrderAccessStorage() {
+	return createShopOrderAccessStorage(new require_key_value_store.MemoryKeyValueStore());
+}
+//#endregion
+//#region src/shop/feature.ts
+const Operation = Object.freeze({
+	RequestCode: "request-code",
+	VerifyCode: "verify-code",
+	List: "list",
+	Get: "get",
+	Pay: "pay"
+});
+function requireEmail(value) {
+	const email = value.trim();
+	if (!email?.includes("@")) throw new require_errors.ItdConfigError("укажите адрес почты");
+	return email;
+}
+/** Создаёт подключаемый модуль для доступа к заказам по коду из письма. */
+function createShopFeature(options = {}) {
+	return {
+		name: "shop",
+		buckets: {
+			[Operation.RequestCode]: { limit: 4 },
+			[Operation.VerifyCode]: { limit: 13 },
+			[Operation.List]: { limit: 150 },
+			[Operation.Get]: { limit: 150 },
+			[Operation.Pay]: { limit: 13 }
+		},
+		operations: {
+			[Operation.RequestCode]: {
+				method: "POST",
+				retrySafety: require_url.RetrySafety.Unsafe,
+				read: require_url.voidResult,
+				bucket: Operation.RequestCode
+			},
+			[Operation.VerifyCode]: {
+				method: "POST",
+				retrySafety: require_url.RetrySafety.Unsafe,
+				bucket: Operation.VerifyCode
+			},
+			[Operation.List]: {
+				method: "GET",
+				retrySafety: require_url.RetrySafety.Safe,
+				bucket: Operation.List
+			},
+			[Operation.Get]: {
+				method: "GET",
+				retrySafety: require_url.RetrySafety.Safe,
+				bucket: Operation.Get
+			},
+			[Operation.Pay]: {
+				method: "POST",
+				retrySafety: require_url.RetrySafety.Unsafe,
+				bucket: Operation.Pay
+			}
+		},
+		setup(context) {
+			const storage = options.storage ?? createMemoryShopOrderAccessStorage();
+			let pendingEmail = null;
+			const readSession = async () => {
+				const session = await storage.get();
+				if (!session) return null;
+				if (session.expiresAt > context.clock.now()) return { ...session };
+				await storage.clear();
+				return null;
+			};
+			const requireSession = async () => {
+				const session = await readSession();
+				if (!session) throw new require_errors.ItdConfigError("доступ к заказам отсутствует или истёк; запросите новый код");
+				return session;
+			};
+			const withAccess = async (run) => {
+				const session = await requireSession();
+				try {
+					return await run(session.token);
+				} catch (error) {
+					if (require_errors.isItdApiError(error) && error.status === 401) await storage.clear();
+					throw error;
+				}
+			};
+			const request = (operation, token, requestOptions) => context.request(operation, {
+				...requestOptions,
+				headers: {
+					...requestOptions.headers,
+					"X-Order-Token": token
+				},
+				skipAuth: true,
+				raw: true
+			});
+			return { api: Object.freeze({
+				async requestCode(email, requestOptions = {}) {
+					const normalized = requireEmail(email);
+					await context.request(Operation.RequestCode, {
+						path: "/api/v1/shop/orders/lookup/request",
+						body: { email: normalized },
+						skipAuth: true,
+						raw: true,
+						...requestOptions
+					});
+					pendingEmail = normalized;
+				},
+				async verifyCode(code, requestOptions = {}) {
+					if (!pendingEmail) throw new require_errors.ItdConfigError("сначала запросите код для адреса почты");
+					const verified = await context.request(Operation.VerifyCode, {
+						path: "/api/v1/shop/orders/lookup/verify",
+						body: {
+							email: pendingEmail,
+							code
+						},
+						skipAuth: true,
+						raw: true,
+						...requestOptions
+					});
+					const session = {
+						email: pendingEmail,
+						token: verified.token,
+						expiresAt: context.clock.now() + verified.expiresInSec * 1e3
+					};
+					await storage.set(session);
+					pendingEmail = null;
+					return { ...session };
+				},
+				session: readSession,
+				async clear() {
+					pendingEmail = null;
+					await storage.clear();
+				},
+				list: (requestOptions = {}) => withAccess((token) => request(Operation.List, token, {
+					path: "/api/v1/shop/orders/my",
+					...requestOptions
+				})),
+				get: (orderNumber, requestOptions = {}) => withAccess((token) => request(Operation.Get, token, {
+					path: `/api/v1/shop/orders/${require_redact.encodePathSegment(orderNumber, "номер заказа")}`,
+					...requestOptions
+				})),
+				pay: (orderNumber, returnUrl, requestOptions = {}) => withAccess((token) => request(Operation.Pay, token, {
+					path: `/api/v1/shop/orders/${require_redact.encodePathSegment(orderNumber, "номер заказа")}/pay`,
+					body: { returnUrl },
+					...requestOptions
+				}))
+			}) };
+		}
+	};
+}
+//#endregion
 //#region src/spans/render.ts
 /** Формат результата {@link renderSpans}. */
 const SpanRenderFormat = Object.freeze({
@@ -4308,16 +5056,22 @@ Object.defineProperty(exports, "ExtensibleOperationCatalog", {
 		return ExtensibleOperationCatalog;
 	}
 });
-Object.defineProperty(exports, "FeatureRegistry", {
+Object.defineProperty(exports, "IMAGE_MIME_TYPES", {
 	enumerable: true,
 	get: function() {
-		return FeatureRegistry;
+		return IMAGE_MIME_TYPES;
 	}
 });
-Object.defineProperty(exports, "IMAGE_MIME_TYPES", {
+Object.defineProperty(exports, "MemoryShopOrderAccessStorage", {
 	enumerable: true,
 	get: function() {
-		return IMAGE_MIME_TYPES;
+		return MemoryShopOrderAccessStorage;
+	}
+});
+Object.defineProperty(exports, "NotificationsResource", {
+	enumerable: true,
+	get: function() {
+		return NotificationsResource;
 	}
 });
 Object.defineProperty(exports, "PaginationMode", {
@@ -4332,6 +5086,30 @@ Object.defineProperty(exports, "Paginator", {
 		return Paginator;
 	}
 });
+Object.defineProperty(exports, "ShopConsentKind", {
+	enumerable: true,
+	get: function() {
+		return ShopConsentKind;
+	}
+});
+Object.defineProperty(exports, "ShopOrderStatus", {
+	enumerable: true,
+	get: function() {
+		return ShopOrderStatus;
+	}
+});
+Object.defineProperty(exports, "ShopProductCategory", {
+	enumerable: true,
+	get: function() {
+		return ShopProductCategory;
+	}
+});
+Object.defineProperty(exports, "ShopProductStatus", {
+	enumerable: true,
+	get: function() {
+		return ShopProductStatus;
+	}
+});
 Object.defineProperty(exports, "SpanRenderFormat", {
 	enumerable: true,
 	get: function() {
@@ -4356,12 +5134,36 @@ Object.defineProperty(exports, "comment", {
 		return comment;
 	}
 });
+Object.defineProperty(exports, "createFeatureHost", {
+	enumerable: true,
+	get: function() {
+		return createFeatureHost;
+	}
+});
+Object.defineProperty(exports, "createMemoryShopOrderAccessStorage", {
+	enumerable: true,
+	get: function() {
+		return createMemoryShopOrderAccessStorage;
+	}
+});
 Object.defineProperty(exports, "createResources", {
 	enumerable: true,
 	get: function() {
 		return createResources;
 	}
 });
+Object.defineProperty(exports, "createShopFeature", {
+	enumerable: true,
+	get: function() {
+		return createShopFeature;
+	}
+});
+Object.defineProperty(exports, "createShopOrderAccessStorage", {
+	enumerable: true,
+	get: function() {
+		return createShopOrderAccessStorage;
+	}
+});
 Object.defineProperty(exports, "createStatusFeature", {
 	enumerable: true,
 	get: function() {
@@ -4459,4 +5261,4 @@ Object.defineProperty(exports, "utcStampToIso", {
 	}
 });
 
-//# sourceMappingURL=render-mcuELiYi.cjs.map
+//# sourceMappingURL=render-Dqi8Owqk.cjs.map