itd-api 0.0.1

package/dist/chunk-QILCVTJI.cjs

@@ -0,0 +1,4885 @@
+'use strict';
+
+// src/builders/base.ts
+var BUILDER = /* @__PURE__ */ Symbol.for("itd.builder");
+function isBuilder(value) {
+  return typeof value === "object" && value !== null && BUILDER in value;
+}
+function resolveInput(input, factory, validate) {
+  if (typeof input === "function") {
+    const result = input(factory());
+    return isBuilder(result) ? result.build() : validate(result);
+  }
+  if (isBuilder(input)) return input.build();
+  return validate(input);
+}
+
+// src/core/errors.ts
+var ITD_ERROR = /* @__PURE__ */ Symbol.for("itd.error");
+var ItdError = class extends Error {
+  /** @internal */
+  [ITD_ERROR] = true;
+  /** Категория ошибки. */
+  kind;
+  constructor(kind, message, options) {
+    super(message, options);
+    this.kind = kind;
+    this.name = "ItdError";
+  }
+};
+var ItdApiError = class extends ItdError {
+  /** HTTP-статус ответа. */
+  status;
+  /** Строковый код ошибки, например `VALIDATION_ERROR`. */
+  code;
+  /** Расширенное описание, если сервер его прислал. */
+  detail;
+  /** Заголовок ошибки, если сервер его прислал. */
+  title;
+  /** Ошибки по полям. Пустой объект, если сервер их не прислал. */
+  fieldErrors;
+  /** Идентификатор запроса из заголовков ответа. */
+  requestId;
+  /** HTTP-метод запроса. */
+  method;
+  /** Путь запроса без базового URL. */
+  path;
+  /** Тело ответа как оно пришло. */
+  raw;
+  /** Объект ответа. Тело уже прочитано и повторно прочитано быть не может. */
+  response;
+  /** Пауза из заголовка `Retry-After` в миллисекундах. Сервер итд.com его не присылает. */
+  retryAfter;
+  /**
+   * Сколько запросов разрешено в окне — заголовок `x-ratelimit-limit`.
+   *
+   * Времени сброса окна сервер не сообщает, поэтому точный момент повтора неизвестен.
+   */
+  rateLimit;
+  /** Сколько запросов осталось в окне — заголовок `x-ratelimit-remaining`. */
+  rateLimitRemaining;
+  constructor(init) {
+    super("api", init.message);
+    this.name = "ItdApiError";
+    this.status = init.status;
+    this.code = init.code;
+    this.detail = init.detail;
+    this.title = init.title;
+    this.fieldErrors = init.fieldErrors ?? {};
+    this.requestId = init.requestId;
+    this.method = init.method;
+    this.path = init.path;
+    this.raw = init.raw;
+    this.response = init.response;
+    this.retryAfter = init.retryAfter;
+    this.rateLimit = init.rateLimit;
+    this.rateLimitRemaining = init.rateLimitRemaining;
+  }
+  /**
+   * Проверяет код ошибки. Удобнее, чем сравнивать строки вручную.
+   *
+   * @example
+   * ```ts
+   * if (err.hasCode('OTP_INVALID', 'MISSING_FLOW_TOKEN')) await restartOtpFlow();
+   * ```
+   */
+  hasCode(...codes) {
+    return codes.includes(this.code);
+  }
+  /** Имеет ли смысл повторить запрос: `429` и серверные ошибки `5xx`. */
+  get isRetryable() {
+    return this.status === 429 || this.status >= 500;
+  }
+};
+var ItdValidationError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdValidationError";
+  }
+};
+var ItdAuthError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdAuthError";
+  }
+};
+var ItdForbiddenError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdForbiddenError";
+  }
+};
+var ItdNotFoundError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdNotFoundError";
+  }
+};
+var ItdConflictError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdConflictError";
+  }
+};
+var ItdRateLimitError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdRateLimitError";
+  }
+};
+var ItdPhoneVerificationError = class extends ItdApiError {
+  /** Ссылка на бота подтверждения, если удалось определить идентификатор пользователя. */
+  verificationUrl;
+  constructor(init) {
+    super(init);
+    this.name = "ItdPhoneVerificationError";
+    this.verificationUrl = init.userId ? `https://t.me/itd_verification_bot?start=${encodeURIComponent(init.userId)}` : void 0;
+  }
+};
+var ItdServerError = class extends ItdApiError {
+  constructor(init) {
+    super(init);
+    this.name = "ItdServerError";
+  }
+};
+var ItdNetworkError = class extends ItdError {
+  /** HTTP-метод запроса. */
+  method;
+  /** Путь запроса без базового URL. */
+  path;
+  constructor(message, init) {
+    super("network", message, { cause: init.cause });
+    this.name = "ItdNetworkError";
+    this.method = init.method;
+    this.path = init.path;
+  }
+};
+var ItdTimeoutError = class extends ItdError {
+  /** Значение таймаута в миллисекундах. */
+  timeout;
+  /** HTTP-метод запроса. */
+  method;
+  /** Путь запроса без базового URL. */
+  path;
+  constructor(init) {
+    super("timeout", `\u0417\u0430\u043F\u0440\u043E\u0441 ${init.method} ${init.path} \u043F\u0440\u0435\u0432\u044B\u0441\u0438\u043B \u0442\u0430\u0439\u043C\u0430\u0443\u0442 ${init.timeout} \u043C\u0441`);
+    this.name = "ItdTimeoutError";
+    this.timeout = init.timeout;
+    this.method = init.method;
+    this.path = init.path;
+  }
+};
+var ItdAbortError = class extends ItdError {
+  constructor(message = "\u0417\u0430\u043F\u0440\u043E\u0441 \u043E\u0442\u043C\u0435\u043D\u0451\u043D") {
+    super("abort", message);
+    this.name = "ItdAbortError";
+  }
+};
+var ItdConfigError = class extends ItdError {
+  constructor(message) {
+    super("config", message);
+    this.name = "ItdConfigError";
+  }
+};
+function isItdError(value) {
+  return typeof value === "object" && value !== null && ITD_ERROR in value;
+}
+function isItdApiError(value) {
+  return isItdError(value) && value.kind === "api";
+}
+function isItdValidationError(value) {
+  return isItdApiError(value) && value instanceof ItdValidationError;
+}
+function isItdAuthError(value) {
+  return isItdApiError(value) && value instanceof ItdAuthError;
+}
+function isItdRateLimitError(value) {
+  return isItdApiError(value) && value instanceof ItdRateLimitError;
+}
+
+// src/builders/comment.ts
+function validateComment(input) {
+  const content = typeof input?.content === "string" ? input.content : "";
+  const attachmentIds = input?.attachmentIds ?? [];
+  const files = input?.files ?? [];
+  const hasContent = content.trim() !== "";
+  const hasAttachments = attachmentIds.length > 0 || files.length > 0;
+  if (!hasContent && !hasAttachments) {
+    throw new ItdConfigError("\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u043F\u0443\u0441\u0442: \u043D\u0443\u0436\u0435\u043D \u0442\u0435\u043A\u0441\u0442 \u0438\u043B\u0438 \u0432\u043B\u043E\u0436\u0435\u043D\u0438\u0435");
+  }
+  return input;
+}
+function validateVoice(state) {
+  if (state.content.trim() !== "") {
+    throw new ItdConfigError(
+      "\u0423 \u0433\u043E\u043B\u043E\u0441\u043E\u0432\u043E\u0433\u043E \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u044F \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0442\u0435\u043A\u0441\u0442\u0430: API \u043F\u0440\u0438\u043D\u0438\u043C\u0430\u0435\u0442 \u043B\u0438\u0431\u043E \u0442\u0435\u043A\u0441\u0442, \u043B\u0438\u0431\u043E \u0430\u0443\u0434\u0438\u043E"
+    );
+  }
+  const total = state.files.length + state.attachmentIds.length;
+  if (total !== 1) {
+    throw new ItdConfigError(
+      `\u0413\u043E\u043B\u043E\u0441\u043E\u0432\u043E\u0439 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0440\u043E\u0432\u043D\u043E \u043E\u0434\u043D\u043E \u0430\u0443\u0434\u0438\u043E\u0432\u043B\u043E\u0436\u0435\u043D\u0438\u0435, \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E: ${total}`
+    );
+  }
+}
+var CommentBuilder = class _CommentBuilder {
+  /** @internal */
+  [BUILDER] = true;
+  #state;
+  /** @internal Создавайте билдер функцией {@link comment}. */
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Задаёт текст комментария. */
+  content(text) {
+    return new _CommentBuilder({ ...this.#state, content: text });
+  }
+  /** Прикладывает файл — он будет загружен перед отправкой. */
+  attach(file) {
+    return new _CommentBuilder({ ...this.#state, files: [...this.#state.files, file] });
+  }
+  /** Прикладывает уже загруженное вложение. */
+  attachId(attachmentId) {
+    return new _CommentBuilder({
+      ...this.#state,
+      attachmentIds: [...this.#state.attachmentIds, attachmentId]
+    });
+  }
+  /**
+   * Делает комментарий голосовым.
+   *
+   * Текста у такого комментария быть не должно, а вложение ровно одно — аудио в формате
+   * `audio/ogg`. Так его принимает API.
+   *
+   * @example
+   * ```ts
+   * await itd.posts.comment(postId, (c) => c.voice('./answer.ogg'));
+   * ```
+   */
+  voice(audio) {
+    return new _CommentBuilder({ ...this.#state, files: [audio], voice: true });
+  }
+  /**
+   * Кому адресован ответ.
+   *
+   * Имеет смысл только в `itd.comments.reply()`; при отправке комментария к посту
+   * это поле вызовет ошибку.
+   */
+  replyTo(userId) {
+    return new _CommentBuilder({ ...this.#state, replyToUserId: userId });
+  }
+  build() {
+    const { content, attachmentIds, files, voice, ...rest } = this.#state;
+    if (voice) validateVoice(this.#state);
+    return validateComment({
+      ...rest,
+      content,
+      ...attachmentIds.length > 0 ? { attachmentIds } : {},
+      ...files.length > 0 ? { files } : {}
+    });
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+function comment(content = "") {
+  return new CommentBuilder({ content, attachmentIds: [], files: [], voice: false });
+}
+function resolveComment(input, allowReplyTo = false) {
+  const resolved = resolveInput(input, () => comment(), validateComment);
+  if (!allowReplyTo && resolved.replyToUserId !== void 0) {
+    throw new ItdConfigError(
+      "replyTo \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u043C \u0442\u043E\u043B\u044C\u043A\u043E \u043A \u043E\u0442\u0432\u0435\u0442\u0443 \u043D\u0430 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 (itd.comments.reply). \u0412 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 \u043A \u043F\u043E\u0441\u0442\u0443 \u0430\u0434\u0440\u0435\u0441\u0430\u0442 \u043D\u0435 \u0443\u043A\u0430\u0437\u044B\u0432\u0430\u0435\u0442\u0441\u044F."
+    );
+  }
+  return resolved;
+}
+
+// src/builders/poll.ts
+var MIN_OPTIONS = 2;
+var MAX_OPTIONS = 10;
+var MAX_QUESTION_LENGTH = 200;
+var MAX_OPTION_LENGTH = 100;
+function validatePoll(input) {
+  const question = input?.question;
+  if (typeof question !== "string" || question.trim() === "") {
+    throw new ItdConfigError("\u041E\u043F\u0440\u043E\u0441 \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0433\u043E \u0432\u043E\u043F\u0440\u043E\u0441\u0430");
+  }
+  if (question.trim().length > MAX_QUESTION_LENGTH) {
+    throw new ItdConfigError(
+      `\u0412\u043E\u043F\u0440\u043E\u0441 \u0434\u043B\u0438\u043D\u043D\u0435\u0435 ${MAX_QUESTION_LENGTH} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432 (\u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E ${question.trim().length})`
+    );
+  }
+  const options = Array.isArray(input.options) ? input.options : [];
+  const texts = options.map((option, index) => {
+    const text = typeof option?.text === "string" ? option.text.trim() : "";
+    if (text === "") {
+      throw new ItdConfigError(`\u0412\u0430\u0440\u0438\u0430\u043D\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u2116${index + 1} \u043F\u0443\u0441\u0442 \u2014 \u0443 \u043A\u0430\u0436\u0434\u043E\u0433\u043E \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0442\u0435\u043A\u0441\u0442`);
+    }
+    if (text.length > MAX_OPTION_LENGTH) {
+      throw new ItdConfigError(
+        `\u0412\u0430\u0440\u0438\u0430\u043D\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u2116${index + 1} \u0434\u043B\u0438\u043D\u043D\u0435\u0435 ${MAX_OPTION_LENGTH} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432 (\u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E ${text.length})`
+      );
+    }
+    return text;
+  });
+  if (texts.length < MIN_OPTIONS) {
+    throw new ItdConfigError(
+      `\u041E\u043F\u0440\u043E\u0441 \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043C\u0438\u043D\u0438\u043C\u0443\u043C ${MIN_OPTIONS} \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u0430, \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E: ${texts.length}`
+    );
+  }
+  if (texts.length > MAX_OPTIONS) {
+    throw new ItdConfigError(
+      `\u041E\u043F\u0440\u043E\u0441 \u0434\u043E\u043F\u0443\u0441\u043A\u0430\u0435\u0442 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${MAX_OPTIONS} \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u043E\u0432, \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E: ${texts.length}`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const text of texts) {
+    if (seen.has(text)) {
+      throw new ItdConfigError(`\u0412\u0430\u0440\u0438\u0430\u043D\u0442 \xAB${text}\xBB \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u0442\u0441\u044F \u2014 \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u044B \u0434\u043E\u043B\u0436\u043D\u044B \u0440\u0430\u0437\u043B\u0438\u0447\u0430\u0442\u044C\u0441\u044F`);
+    }
+    seen.add(text);
+  }
+  return {
+    question: question.trim(),
+    options: texts.map((text) => ({ text })),
+    // Поле обязательно: без него сервер отвергает создание поста с опросом,
+    // даже когда выбор одиночный.
+    multipleChoice: input.multipleChoice ?? false
+  };
+}
+var PollBuilder = class _PollBuilder {
+  /** @internal */
+  [BUILDER] = true;
+  #state;
+  /** @internal Создавайте билдер функцией {@link poll}. */
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Задаёт вопрос. */
+  question(text) {
+    return new _PollBuilder({ ...this.#state, question: text });
+  }
+  /** Добавляет один вариант ответа. */
+  option(text) {
+    return new _PollBuilder({ ...this.#state, options: [...this.#state.options, { text }] });
+  }
+  /**
+   * Добавляет несколько вариантов сразу.
+   *
+   * @example
+   * ```ts
+   * poll('ну как?').options('да', 'нет', 'не знаю');
+   * ```
+   */
+  options(...texts) {
+    return new _PollBuilder({
+      ...this.#state,
+      options: [...this.#state.options, ...texts.map((text) => ({ text }))]
+    });
+  }
+  /** Разрешает выбор нескольких вариантов. */
+  multipleChoice(enabled = true) {
+    return new _PollBuilder({ ...this.#state, multipleChoice: enabled });
+  }
+  build() {
+    return validatePoll(this.#state);
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+function poll(question = "") {
+  return new PollBuilder({ question, options: [] });
+}
+function resolvePoll(input) {
+  return resolveInput(input, () => poll(), validatePoll);
+}
+
+// src/builders/post.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function validatePost(input) {
+  const content = typeof input?.content === "string" ? input.content : "";
+  const attachmentIds = input?.attachmentIds ?? [];
+  const files = input?.files ?? [];
+  const hasContent = content.trim() !== "";
+  const hasAttachments = attachmentIds.length > 0 || files.length > 0;
+  const hasPoll = Boolean(input?.poll);
+  if (!hasContent && !hasAttachments && !hasPoll) {
+    throw new ItdConfigError("\u041F\u043E\u0441\u0442 \u043F\u0443\u0441\u0442: \u043D\u0443\u0436\u0435\u043D \u0442\u0435\u043A\u0441\u0442, \u0432\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \u0438\u043B\u0438 \u043E\u043F\u0440\u043E\u0441");
+  }
+  const wallRecipientId = input.wallRecipientId;
+  if (wallRecipientId !== void 0 && wallRecipientId !== null) {
+    if (!UUID_PATTERN.test(wallRecipientId)) {
+      throw new ItdConfigError(
+        `wallRecipientId \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C UUID, \u0430 \u043D\u0435 \u0438\u043C\u0435\u043D\u0435\u043C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F (\u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: \xAB${wallRecipientId}\xBB). \u0418\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440 \u043C\u043E\u0436\u043D\u043E \u0432\u0437\u044F\u0442\u044C \u0438\u0437 \u043F\u0440\u043E\u0444\u0438\u043B\u044F: (await itd.users.get(username)).id`
+      );
+    }
+  }
+  return input.poll === void 0 ? input : { ...input, poll: resolvePoll(input.poll) };
+}
+var PostBuilder = class _PostBuilder {
+  /** @internal */
+  [BUILDER] = true;
+  #state;
+  /** @internal Создавайте билдер функцией {@link post}. */
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Задаёт текст поста, заменяя прежний. */
+  content(text) {
+    return new _PostBuilder({ ...this.#state, content: text });
+  }
+  /** Дописывает текст к уже заданному. */
+  append(text) {
+    const separator = this.#state.content === "" ? "" : "\n";
+    return new _PostBuilder({ ...this.#state, content: this.#state.content + separator + text });
+  }
+  /**
+   * Задаёт разметку текста.
+   *
+   * Библиотека разметку не генерирует: хэштеги и упоминания нужно размечать самостоятельно
+   * либо не размечать вовсе.
+   */
+  spans(spans) {
+    return new _PostBuilder({ ...this.#state, spans });
+  }
+  /**
+   * Публикует пост на стене другого пользователя.
+   *
+   * @param userId **UUID** пользователя; имя пользователя не подойдёт
+   */
+  onWall(userId) {
+    return new _PostBuilder({ ...this.#state, wallRecipientId: userId });
+  }
+  /**
+   * Прикладывает файл — он будет загружен перед публикацией.
+   *
+   * Порядок вызовов сохраняется в порядке вложений.
+   */
+  attach(file) {
+    return new _PostBuilder({ ...this.#state, files: [...this.#state.files, file] });
+  }
+  /** Прикладывает уже загруженное вложение по его идентификатору. */
+  attachId(attachmentId) {
+    return new _PostBuilder({
+      ...this.#state,
+      attachmentIds: [...this.#state.attachmentIds, attachmentId]
+    });
+  }
+  /**
+   * Добавляет опрос.
+   *
+   * Принимает объект, {@link PollBuilder} или функцию-настройщик.
+   *
+   * @example
+   * ```ts
+   * post('голосуем').poll((q) => q.question('ну как?').options('да', 'нет'));
+   * ```
+   */
+  poll(input) {
+    return new _PostBuilder({ ...this.#state, poll: resolvePoll(input) });
+  }
+  build() {
+    const { content, attachmentIds, files, ...rest } = this.#state;
+    return validatePost({
+      ...rest,
+      ...content !== "" ? { content } : {},
+      ...attachmentIds.length > 0 ? { attachmentIds } : {},
+      ...files.length > 0 ? { files } : {}
+    });
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+function post(content = "") {
+  return new PostBuilder({ content, attachmentIds: [], files: [] });
+}
+function resolvePost(input) {
+  return resolveInput(input, () => post(), validatePost);
+}
+
+// src/types/enums.ts
+var FeedTab = Object.freeze({
+  /** Популярное. Курсор здесь — номер страницы в виде строки (`"2"`, `"6"`…). */
+  Popular: "popular",
+  /** Записи тех, на кого вы подписаны. Курсор — отметка времени последнего поста. */
+  Following: "following",
+  /** Лента клана. Курсор, как и в подписках, — отметка времени. */
+  Clan: "clan"
+});
+var CommentSort = Object.freeze({
+  /** Сначала новые. */
+  Newest: "newest",
+  /** Сначала старые. */
+  Oldest: "oldest",
+  /** Сначала популярные. */
+  Popular: "popular"
+});
+var AttachmentType = Object.freeze({
+  Image: "image",
+  Video: "video",
+  /** Голосовые комментарии: `audio/ogg`, с полем `duration`. */
+  Audio: "audio"
+});
+var ReportTargetType = Object.freeze({
+  Post: "post",
+  Comment: "comment",
+  User: "user"
+});
+var ReportReason = Object.freeze({
+  Spam: "spam",
+  Violence: "violence",
+  Hate: "hate",
+  Adult: "adult",
+  Fraud: "fraud",
+  Other: "other"
+});
+var RealtimeStatus = Object.freeze({
+  Connecting: "connecting",
+  Connected: "connected",
+  Error: "error",
+  Disconnected: "disconnected"
+});
+var WallAccess = Object.freeze({
+  Everyone: "everyone"
+});
+var LikesVisibility = Object.freeze({
+  Everyone: "everyone",
+  /** Только взаимные подписки. */
+  Mutual: "mutual"
+});
+var NotificationType = Object.freeze({
+  /** Реакция на пост. Старое имя — `like`. */
+  PostReaction: "post_reaction",
+  /** Комментарий к посту. Старое имя — `comment`. */
+  PostComment: "post_comment",
+  /** Ответ на комментарий. Старое имя — `reply`. */
+  CommentReply: "comment_reply",
+  /** Репост. Старое имя — `repost`. */
+  PostRepost: "post_repost",
+  /** Упоминание в посте. Старое имя — `mention`. */
+  PostMention: "post_mention",
+  /** Реакция на комментарий. */
+  CommentReaction: "comment_reaction",
+  /** Упоминание в комментарии. */
+  CommentMention: "comment_mention",
+  /** Запись на вашей стене. */
+  WallPost: "wall_post",
+  /** На вас подписались. */
+  Follow: "follow",
+  /** Заявка на подписку (закрытый профиль). */
+  FollowRequest: "follow_request",
+  /** Заявка на подписку принята. */
+  FollowAccepted: "follow_accepted",
+  /** Верификация одобрена. Приходит только по REST. */
+  VerificationApproved: "verification_approved",
+  /** Верификация отклонена. Приходит только по REST. */
+  VerificationRejected: "verification_rejected"
+});
+var ItdErrorCode = Object.freeze({
+  BAD_REQUEST: "BAD_REQUEST",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  ENTITY_NOT_FOUND: "ENTITY_NOT_FOUND",
+  ENTITY_ALREADY_EXISTS: "ENTITY_ALREADY_EXISTS",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  BUSINESS_RULE_VIOLATION: "BUSINESS_RULE_VIOLATION",
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  CAPTCHA_FAILED: "CAPTCHA_FAILED",
+  OTP_INVALID: "OTP_INVALID",
+  ACCOUNT_DEACTIVATED: "ACCOUNT_DEACTIVATED",
+  ACCOUNT_EMAIL_DOMAIN_NOT_ALLOWED: "ACCOUNT_EMAIL_DOMAIN_NOT_ALLOWED",
+  ACCOUNT_INVALID_CREDENTIALS: "ACCOUNT_INVALID_CREDENTIALS",
+  ACCOUNT_TEMPORARILY_LOCKED: "ACCOUNT_TEMPORARILY_LOCKED",
+  ACCOUNT_CURRENT_PASSWORD_INCORRECT: "ACCOUNT_CURRENT_PASSWORD_INCORRECT",
+  SESSION_EXPIRED: "SESSION_EXPIRED",
+  SESSION_REVOKED: "SESSION_REVOKED",
+  SESSION_INVALID_REFRESH_TOKEN: "SESSION_INVALID_REFRESH_TOKEN",
+  MISSING_FLOW_TOKEN: "MISSING_FLOW_TOKEN",
+  PROFILE_USERNAME_TAKEN: "PROFILE_USERNAME_TAKEN",
+  PROFILE_RESTRICTION_ACTIVE: "PROFILE_RESTRICTION_ACTIVE",
+  PROFILE_MODIFICATION_RESTRICTED: "PROFILE_MODIFICATION_RESTRICTED",
+  CONTENT_MODERATION_FAILED: "CONTENT_MODERATION_FAILED",
+  FILE_TOO_LARGE: "FILE_TOO_LARGE",
+  UNSUPPORTED_FILE_TYPE: "UNSUPPORTED_FILE_TYPE",
+  UPLOAD_FAILED: "UPLOAD_FAILED",
+  VIDEO_REQUIRES_VERIFICATION: "VIDEO_REQUIRES_VERIFICATION",
+  PHONE_VERIFICATION_REQUIRED: "PHONE_VERIFICATION_REQUIRED",
+  WRITE_ACCESS_RESTRICTED: "WRITE_ACCESS_RESTRICTED"
+});
+
+// src/builders/report.ts
+var REASONS = new Set(Object.values(ReportReason));
+function validateReport(input) {
+  if (!input?.targetId || typeof input.targetId !== "string") {
+    throw new ItdConfigError("\u0416\u0430\u043B\u043E\u0431\u0430 \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440 \u043E\u0431\u044A\u0435\u043A\u0442\u0430 (targetId)");
+  }
+  if (input.targetType !== "post" && input.targetType !== "comment" && input.targetType !== "user") {
+    throw new ItdConfigError(
+      `targetType \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C 'post', 'comment' \u0438\u043B\u0438 'user', \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${String(input.targetType)}`
+    );
+  }
+  if (!REASONS.has(input.reason)) {
+    throw new ItdConfigError(
+      `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043F\u0440\u0438\u0447\u0438\u043D\u0430 \u0436\u0430\u043B\u043E\u0431\u044B \xAB${String(input.reason)}\xBB. \u0414\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0435: ${[...REASONS].join(", ")}`
+    );
+  }
+  return input;
+}
+var ReportBuilder = class _ReportBuilder {
+  /** @internal */
+  [BUILDER] = true;
+  #state;
+  /** @internal Создавайте билдер через {@link report}. */
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Указывает причину жалобы. */
+  reason(reason) {
+    return new _ReportBuilder({ ...this.#state, reason });
+  }
+  /** Добавляет пояснение в свободной форме. */
+  description(text) {
+    return new _ReportBuilder({ ...this.#state, description: text });
+  }
+  build() {
+    return validateReport(this.#state);
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+function start(targetType, targetId) {
+  return new ReportBuilder({ targetType, targetId });
+}
+var report = Object.freeze({
+  /** Жалоба на пост. */
+  post: (postId) => start("post", postId),
+  /** Жалоба на комментарий. */
+  comment: (commentId) => start("comment", commentId),
+  /** Жалоба на пользователя. */
+  user: (userId) => start("user", userId)
+});
+function resolveReport(input) {
+  return resolveInput(input, () => new ReportBuilder({}), validateReport);
+}
+
+// node_modules/set-cookie-parser/lib/set-cookie.js
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false,
+  split: "auto"
+  // auto = split strings but not arrays
+};
+function isForbiddenKey(key) {
+  return typeof key !== "string" || key in {};
+}
+function createNullObj() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+  var nameValuePairStr = parts.shift();
+  if (!nameValuePairStr) {
+    return null;
+  }
+  var parsed = parseNameValuePair(nameValuePairStr);
+  var name = parsed.name;
+  var value = parsed.value;
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (isForbiddenKey(name)) {
+    return null;
+  }
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value;
+  } catch (e) {
+    console.error(
+      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
+      e
+    );
+  }
+  var cookie = createNullObj();
+  cookie.name = name;
+  cookie.value = value;
+  parts.forEach(function(part) {
+    var sides = part.split("=");
+    var key = sides.shift().trim().toLowerCase();
+    if (isForbiddenKey(key)) {
+      return;
+    }
+    var value2 = sides.join("=").trim();
+    if (key === "expires") {
+      cookie.expires = new Date(value2);
+    } else if (key === "max-age") {
+      var n = parseInt(value2, 10);
+      if (!Number.isNaN(n)) cookie.maxAge = n;
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value2;
+    } else if (key === "partitioned") {
+      cookie.partitioned = true;
+    } else if (key) {
+      cookie[key] = value2;
+    }
+  });
+  return cookie;
+}
+function parseNameValuePair(nameValuePairStr) {
+  var name = "";
+  var value = "";
+  var nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("=");
+  } else {
+    value = nameValuePairStr;
+  }
+  return { name, value };
+}
+function parseSetCookie(input, options) {
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return createNullObj();
+    }
+  }
+  if (input.headers) {
+    if (typeof input.headers.getSetCookie === "function") {
+      input = input.headers.getSetCookie();
+    } else if (input.headers["set-cookie"]) {
+      input = input.headers["set-cookie"];
+    } else {
+      var sch = input.headers[Object.keys(input.headers).find(function(key) {
+        return key.toLowerCase() === "set-cookie";
+      })];
+      if (!sch && input.headers.cookie && !options.silent) {
+        console.warn(
+          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+        );
+      }
+      input = sch;
+    }
+  }
+  var split = options.split;
+  var isArray = Array.isArray(input);
+  if (split === "auto") {
+    split = !isArray;
+  }
+  if (!isArray) {
+    input = [input];
+  }
+  input = input.filter(isNonEmptyString);
+  if (split) {
+    input = input.map(splitCookiesString).flat();
+  }
+  if (!options.map) {
+    return input.map(function(str) {
+      return parseString(str, options);
+    }).filter(Boolean);
+  } else {
+    var cookies = createNullObj();
+    return input.reduce(function(cookies2, str) {
+      var cookie = parseString(str, options);
+      if (cookie && !isForbiddenKey(cookie.name)) {
+        cookies2[cookie.name] = cookie;
+      }
+      return cookies2;
+    }, cookies);
+  }
+}
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  var cookiesStrings = [];
+  var pos = 0;
+  var start2;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start2 = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start2, lastComma));
+          start2 = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start2, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+parseSetCookie.parseSetCookie = parseSetCookie;
+parseSetCookie.parse = parseSetCookie;
+parseSetCookie.parseString = parseString;
+parseSetCookie.splitCookiesString = splitCookiesString;
+
+// src/core/cookies.ts
+var AUTH_FLAG_COOKIE = "is_auth";
+var SERIALIZED_SEPARATOR = " ";
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "";
+  }
+}
+function toTimestamp(date) {
+  if (!date) return void 0;
+  const time = date.getTime();
+  return Number.isFinite(time) ? time : void 0;
+}
+function pathOf(url) {
+  try {
+    return new URL(url).pathname || "/";
+  } catch {
+    return "/";
+  }
+}
+function pathMatches(cookiePath, requestPath) {
+  if (cookiePath === "/" || cookiePath === requestPath) return true;
+  if (!requestPath.startsWith(cookiePath)) return false;
+  return cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/";
+}
+var CookieJar = class {
+  #byOrigin = /* @__PURE__ */ new Map();
+  /**
+   * Забирает `Set-Cookie` из ответа.
+   *
+   * Использует `Headers.getSetCookie()`, где он есть (Node 20+, undici). В остальных средах
+   * заголовки склеены в одну строку, и её нельзя резать по запятой напрямую: запятая есть
+   * внутри `Expires=Wed, 09 Jun 2027 …`. Разделением занимается `set-cookie-parser`.
+   */
+  setFromResponse(url, response) {
+    const headers = response.headers;
+    const raw = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : splitCookiesString(headers.get("set-cookie") ?? "");
+    if (raw.length > 0) this.setFromStrings(url, raw);
+  }
+  /** Сохраняет cookie из готовых строк `Set-Cookie`. */
+  setFromStrings(url, setCookieStrings) {
+    const origin = originOf(url);
+    if (!origin) return;
+    const jar = this.#byOrigin.get(origin) ?? /* @__PURE__ */ new Map();
+    for (const parsed of parseSetCookie(setCookieStrings)) {
+      const expires = toTimestamp(parsed.expires);
+      const maxAgeExpires = typeof parsed.maxAge === "number" && Number.isFinite(parsed.maxAge) ? Date.now() + parsed.maxAge * 1e3 : void 0;
+      const expiresAt = maxAgeExpires ?? expires;
+      if (expiresAt !== void 0 && expiresAt <= Date.now()) {
+        jar.delete(parsed.name);
+        continue;
+      }
+      jar.set(parsed.name, {
+        name: parsed.name,
+        value: parsed.value,
+        path: parsed.path ?? "/",
+        expires: expiresAt,
+        secure: parsed.secure ?? false
+      });
+    }
+    this.#byOrigin.set(origin, jar);
+  }
+  /**
+   * Собирает значение заголовка `Cookie` для запроса.
+   *
+   * @returns строка вида `a=1; b=2` либо `undefined`, если подходящих cookie нет
+   */
+  getHeader(url) {
+    const cookies = this.#matching(url);
+    if (cookies.length === 0) return void 0;
+    return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
+  }
+  /**
+   * Есть ли действующая cookie с таким именем.
+   *
+   * Используется для проверки флага {@link AUTH_FLAG_COOKIE} перед запросом обновления
+   * токена: у анонима refresh-сессии нет, и дёргать API незачем.
+   */
+  has(name, url) {
+    if (url) return this.#matching(url).some((cookie) => cookie.name === name);
+    const now = Date.now();
+    for (const jar of this.#byOrigin.values()) {
+      const cookie = jar.get(name);
+      if (cookie && (cookie.expires === void 0 || cookie.expires > now)) return true;
+    }
+    return false;
+  }
+  /** Сохраняет содержимое jar для записи в {@link TokenStorage}. */
+  serialize() {
+    const result = [];
+    const now = Date.now();
+    for (const [origin, jar] of this.#byOrigin) {
+      for (const cookie of jar.values()) {
+        if (cookie.expires !== void 0 && cookie.expires <= now) continue;
+        const parts = [`${cookie.name}=${cookie.value}`, `Path=${cookie.path}`];
+        if (cookie.expires !== void 0) {
+          parts.push(`Expires=${new Date(cookie.expires).toUTCString()}`);
+        }
+        if (cookie.secure) parts.push("Secure");
+        result.push(`${origin}${SERIALIZED_SEPARATOR}${parts.join("; ")}`);
+      }
+    }
+    return result;
+  }
+  /** Восстанавливает jar из результата {@link serialize}. Некорректные записи молча пропускаются. */
+  deserialize(entries) {
+    if (!entries) return;
+    for (const entry of entries) {
+      const separatorAt = entry.indexOf(SERIALIZED_SEPARATOR);
+      if (separatorAt <= 0) continue;
+      const origin = entry.slice(0, separatorAt);
+      const setCookie = entry.slice(separatorAt + 1);
+      if (!originOf(origin)) continue;
+      this.setFromStrings(origin, [setCookie]);
+    }
+  }
+  /** Удаляет все cookie. */
+  clear() {
+    this.#byOrigin.clear();
+  }
+  /** Действующие cookie, подходящие запросу: тот же origin, подходящий путь, не истёкшие. */
+  #matching(url) {
+    const origin = originOf(url);
+    const jar = this.#byOrigin.get(origin);
+    if (!jar) return [];
+    const isSecureRequest = origin.startsWith("https:");
+    const requestPath = pathOf(url);
+    const now = Date.now();
+    const result = [];
+    for (const cookie of jar.values()) {
+      if (cookie.expires !== void 0 && cookie.expires <= now) {
+        jar.delete(cookie.name);
+        continue;
+      }
+      if (cookie.secure && !isSecureRequest) continue;
+      if (!pathMatches(cookie.path, requestPath)) continue;
+      result.push(cookie);
+    }
+    return result;
+  }
+};
+
+// src/core/emitter.ts
+var Emitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  #onError;
+  constructor(onListenerError) {
+    this.#onError = onListenerError;
+  }
+  /**
+   * Подписывается на событие.
+   *
+   * @returns функция отписки
+   *
+   * @example
+   * ```ts
+   * const off = realtime.on('notification', (event) => console.log(event));
+   * off();
+   * ```
+   */
+  on(event, listener) {
+    const set = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.#listeners.set(event, set);
+    return () => this.off(event, listener);
+  }
+  /** Подписывается на одно срабатывание. */
+  once(event, listener) {
+    const off = this.on(event, (payload) => {
+      off();
+      listener(payload);
+    });
+    return off;
+  }
+  /** Отписывается от события. */
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  /** Рассылает событие подписчикам. */
+  emit(event, payload) {
+    const set = this.#listeners.get(event);
+    if (!set) return;
+    for (const listener of [...set]) {
+      try {
+        listener(payload);
+      } catch (error) {
+        this.#onError?.(error);
+      }
+    }
+  }
+  /** Сколько подписчиков у события. */
+  listenerCount(event) {
+    return this.#listeners.get(event)?.size ?? 0;
+  }
+  /** Снимает все подписки. */
+  removeAllListeners() {
+    this.#listeners.clear();
+  }
+};
+
+// src/core/auth.ts
+var AUTH_PATHS = {
+  signIn: "/api/v1/auth/sign-in",
+  refresh: "/api/v1/auth/refresh"
+};
+function readAccessToken(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const token = payload.accessToken;
+  return typeof token === "string" && token.length > 0 ? token : void 0;
+}
+var AuthManager = class {
+  #config;
+  #http;
+  #jar;
+  #emitter = new Emitter();
+  /** `undefined` — сессия ещё не читалась из хранилища. */
+  #session;
+  /** Общий промис обновления: к нему присоединяются все, кто получил 401. */
+  #refreshing = null;
+  /** Общий промис входа по логину и паролю. */
+  #signingIn = null;
+  constructor(config, http, jar) {
+    this.#config = config;
+    this.#http = http;
+    this.#jar = jar;
+  }
+  /** Подписка на события авторизации. */
+  get on() {
+    return this.#emitter.on.bind(this.#emitter);
+  }
+  /** Подписка на одно срабатывание. */
+  get once() {
+    return this.#emitter.once.bind(this.#emitter);
+  }
+  /**
+   * Есть ли признак живой refresh-сессии.
+   *
+   * Сайт итд.com ставит рядом с refresh-токеном незакрытую cookie `is_auth` — по ней клиент
+   * понимает, что обновление вообще имеет смысл, и не дёргает API у анонимов.
+   * В браузере cookie ведёт сама среда, поэтому там ответ всегда `true`.
+   */
+  hasRefreshSession() {
+    if (!this.#config.useCookieJar) return true;
+    if (this.#jar.has(AUTH_FLAG_COOKIE)) return true;
+    return Boolean(this.#session?.refreshToken);
+  }
+  /** Заголовки авторизации для очередного запроса. Пустой объект, если токена нет. */
+  async getAuthHeaders() {
+    const token = await this.getAccessToken();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  /**
+   * Текущий токен доступа.
+   *
+   * При необходимости выполняет отложенный вход: если в конфигурации переданы логин
+   * и пароль, первый же запрос сам заведёт сессию.
+   */
+  async getAccessToken() {
+    const session = await this.#loadSession();
+    if (session?.accessToken) return session.accessToken;
+    const auth = this.#config.auth;
+    if (!auth) return null;
+    if (typeof auth === "object" && "getToken" in auth) {
+      return await auth.getToken() ?? null;
+    }
+    if (typeof auth === "object" && "email" in auth) {
+      return this.#signInWithCredentials(auth.email, auth.password);
+    }
+    return null;
+  }
+  /**
+   * Реакция транспорта на ответ `401`.
+   *
+   * @returns `true`, если токен обновлён и запрос имеет смысл повторить
+   */
+  async onUnauthorized() {
+    try {
+      const token = await this.#refreshDeduplicated();
+      if (token !== null) return true;
+      this.#emitter.emit("authError", { error: this.#noRefreshSessionError() });
+      return false;
+    } catch (error) {
+      this.#emitter.emit("authError", { error });
+      return false;
+    }
+  }
+  /** Ошибка «сессию продлить нечем» — одна и та же для `refresh()` и для реакции на 401. */
+  #noRefreshSessionError() {
+    return new ItdAuthError({
+      status: 401,
+      code: "SESSION_EXPIRED",
+      message: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0441\u0435\u0441\u0441\u0438\u044E: \u043D\u0435\u0442 \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u044E\u0449\u0435\u0433\u043E refresh-\u0442\u043E\u043A\u0435\u043D\u0430",
+      method: "POST",
+      path: AUTH_PATHS.refresh,
+      raw: void 0
+    });
+  }
+  /**
+   * Обновляет токен доступа.
+   *
+   * Параллельные вызовы объединяются в один сетевой запрос.
+   *
+   * @throws {ItdAuthError} если обновить сессию не удалось
+   */
+  async refresh() {
+    const token = await this.#refreshDeduplicated();
+    if (token === null) throw this.#noRefreshSessionError();
+    return token;
+  }
+  /** Сохраняет токен, полученный извне, — например после подтверждения OTP. */
+  async setAccessToken(accessToken) {
+    await this.#saveSession({ ...this.#session ?? {}, accessToken, obtainedAt: Date.now() });
+    this.#emitter.emit("tokens", { accessToken });
+  }
+  /** Текущая сессия целиком. Полезно, чтобы сохранить её самому. */
+  async getSession() {
+    return this.#loadSession();
+  }
+  /** Заменяет сессию целиком. */
+  async setSession(session) {
+    this.#jar.deserialize(session.cookies);
+    await this.#saveSession(session);
+  }
+  /** Забывает сессию и cookie. Сетевой запрос не выполняется. */
+  async clear() {
+    this.#session = null;
+    this.#jar.clear();
+    await this.#config.storage.clear();
+    this.#emitter.emit("signOut", void 0);
+  }
+  async #loadSession() {
+    if (this.#session !== void 0) return this.#session;
+    const stored = await this.#config.storage.get() ?? null;
+    if (stored?.cookies) this.#jar.deserialize(stored.cookies);
+    const fromConfig = this.#sessionFromConfig(this.#config.auth);
+    this.#session = stored && fromConfig ? {
+      ...stored,
+      accessToken: stored.accessToken ?? fromConfig.accessToken,
+      refreshToken: stored.refreshToken ?? fromConfig.refreshToken
+    } : stored ?? fromConfig;
+    return this.#session;
+  }
+  #sessionFromConfig(auth) {
+    if (!auth) return null;
+    if (typeof auth === "string") return { accessToken: auth, obtainedAt: Date.now() };
+    if ("accessToken" in auth) {
+      return {
+        accessToken: auth.accessToken,
+        refreshToken: auth.refreshToken,
+        obtainedAt: Date.now()
+      };
+    }
+    return null;
+  }
+  async #saveSession(session) {
+    const cookies = this.#config.useCookieJar ? this.#jar.serialize() : void 0;
+    const next = { ...session, ...cookies?.length ? { cookies } : {} };
+    this.#session = next;
+    await this.#config.storage.set(next);
+  }
+  /**
+   * Обновление с дедупликацией.
+   *
+   * Все, кто пришёл, пока обновление уже идёт, получают его результат, а не запускают своё.
+   */
+  #refreshDeduplicated() {
+    if (this.#refreshing) return this.#refreshing;
+    const promise = this.#performRefresh().finally(() => {
+      this.#refreshing = null;
+    });
+    this.#refreshing = promise;
+    return promise;
+  }
+  async #performRefresh() {
+    await this.#loadSession();
+    if (!this.hasRefreshSession()) {
+      return this.#reloginOrNull();
+    }
+    try {
+      const payload = await this.#http.request({
+        method: "POST",
+        path: AUTH_PATHS.refresh,
+        // Обновление опирается на cookie, а не на устаревший Bearer.
+        skipAuth: true,
+        // Без этого 401 на самом обновлении вызвал бы новое обновление — и так по кругу.
+        skipAuthRefresh: true,
+        ...this.#session?.refreshToken ? { body: { refreshToken: this.#session.refreshToken } } : {}
+      });
+      const accessToken = readAccessToken(payload);
+      if (!accessToken) return this.#reloginOrNull();
+      await this.#saveSession({
+        ...this.#session ?? {},
+        accessToken,
+        obtainedAt: Date.now()
+      });
+      this.#emitter.emit("tokens", { accessToken });
+      return accessToken;
+    } catch (error) {
+      if (error instanceof ItdApiError) {
+        this.#session = null;
+        await this.#config.storage.clear();
+        return this.#reloginOrNull();
+      }
+      throw error;
+    }
+  }
+  /** Повторный вход, если разрешён настройкой и есть логин с паролем. */
+  async #reloginOrNull() {
+    const auth = this.#config.auth;
+    if (!this.#config.reloginOnRefreshFailure || !auth || typeof auth !== "object" || !("email" in auth)) {
+      return null;
+    }
+    try {
+      return await this.#signInWithCredentials(auth.email, auth.password);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Вход по логину и паролю.
+   *
+   * Параллельные вызовы объединяются: одновременный старт нескольких запросов не должен
+   * приводить к нескольким попыткам входа и блокировке аккаунта.
+   */
+  #signInWithCredentials(email, password) {
+    if (this.#signingIn) return this.#signingIn;
+    const promise = this.#performSignIn(email, password).finally(() => {
+      this.#signingIn = null;
+    });
+    this.#signingIn = promise;
+    return promise;
+  }
+  async #performSignIn(email, password) {
+    const payload = await this.#http.request({
+      method: "POST",
+      path: AUTH_PATHS.signIn,
+      body: { email, password },
+      skipAuth: true,
+      skipAuthRefresh: true
+    });
+    const accessToken = readAccessToken(payload);
+    if (!accessToken) {
+      throw new ItdConfigError(
+        "\u0412\u0445\u043E\u0434 \u043F\u043E email \u0438 \u043F\u0430\u0440\u043E\u043B\u044E \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F \u043A\u043E\u0434\u043E\u043C \u0438\u0437 \u043F\u0438\u0441\u044C\u043C\u0430. \u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u0439 \u0432\u0445\u043E\u0434 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D: \u0432\u043E\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435\u0441\u044C itd.auth.signInWithOtp() \u0438 \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043D\u044B\u0439 accessToken \u0432 \u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u044E \u043A\u043B\u0438\u0435\u043D\u0442\u0430."
+      );
+    }
+    await this.#saveSession({ accessToken, obtainedAt: Date.now() });
+    this.#emitter.emit("tokens", { accessToken });
+    this.#emitter.emit("signIn", { accessToken });
+    return accessToken;
+  }
+};
+
+// src/core/runtime.ts
+function detectRuntime() {
+  const nav = globalThis.navigator;
+  if (nav?.product === "ReactNative") return "react-native";
+  if (typeof document !== "undefined") return "browser";
+  return "server";
+}
+function shouldUseCookieJar(mode) {
+  if (mode === "browser") return false;
+  if (mode === "server") return true;
+  return detectRuntime() === "server";
+}
+function shouldSendCredentials(mode) {
+  if (mode === "browser") return true;
+  if (mode === "server") return false;
+  return detectRuntime() === "browser";
+}
+function resolveFetch(custom) {
+  if (custom) return custom;
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new ItdConfigError(
+    "\u0412 \u044D\u0442\u043E\u0439 \u0441\u0440\u0435\u0434\u0435 \u043D\u0435\u0442 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u043E\u0433\u043E fetch. \u041E\u0431\u043D\u043E\u0432\u0438\u0442\u0435\u0441\u044C \u0434\u043E Node 18+ \u043B\u0438\u0431\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0441\u0432\u043E\u044E \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044E \u0447\u0435\u0440\u0435\u0437 \u043E\u043F\u0446\u0438\u044E fetch."
+  );
+}
+function supportsStreamingBody() {
+  return typeof ReadableStream !== "undefined" && typeof TextDecoder !== "undefined";
+}
+function hasLocalStorage() {
+  try {
+    return typeof globalThis.localStorage !== "undefined" && globalThis.localStorage !== null;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/storage.ts
+var MemoryTokenStorage = class {
+  #session = null;
+  constructor(initial) {
+    this.#session = initial ?? null;
+  }
+  get() {
+    return this.#session;
+  }
+  set(session) {
+    this.#session = session;
+  }
+  clear() {
+    this.#session = null;
+  }
+};
+var LocalStorageTokenStorage = class {
+  #key;
+  #fallback = new MemoryTokenStorage();
+  #available;
+  /** @param key ключ в `localStorage`. По умолчанию `itd-api:session`. */
+  constructor(key = "itd-api:session") {
+    this.#key = key;
+    this.#available = hasLocalStorage();
+  }
+  get() {
+    if (!this.#available) return this.#fallback.get();
+    try {
+      const raw = globalThis.localStorage.getItem(this.#key);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      return typeof parsed === "object" && parsed !== null ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  set(session) {
+    if (!this.#available) {
+      this.#fallback.set(session);
+      return;
+    }
+    try {
+      globalThis.localStorage.setItem(this.#key, JSON.stringify(session));
+    } catch {
+      this.#fallback.set(session);
+    }
+  }
+  clear() {
+    if (!this.#available) {
+      this.#fallback.clear();
+      return;
+    }
+    try {
+      globalThis.localStorage.removeItem(this.#key);
+    } catch {
+      this.#fallback.clear();
+    }
+  }
+};
+function createTokenStorage(handlers) {
+  return handlers;
+}
+
+// src/core/url.ts
+function buildQuery(params) {
+  if (!params) return "";
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null) continue;
+        search.append(key, String(item));
+      }
+      continue;
+    }
+    search.append(key, String(value));
+  }
+  const query = search.toString();
+  return query ? `?${query}` : "";
+}
+function encodePathSegment(value, name = "\u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u043F\u0443\u0442\u0438") {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ItdConfigError(
+      `${name} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u043E\u0439, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${JSON.stringify(value)}`
+    );
+  }
+  return encodeURIComponent(value);
+}
+function joinUrl(baseUrl, path) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${suffix}`;
+}
+function normalizeBaseUrl(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    throw new ItdConfigError(
+      `baseUrl \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0430\u0431\u0441\u043E\u043B\u044E\u0442\u043D\u044B\u043C URL, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${JSON.stringify(baseUrl)}`
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ItdConfigError(
+      `baseUrl \u0434\u043E\u043B\u0436\u0435\u043D \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C http \u0438\u043B\u0438 https, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${parsed.protocol}`
+    );
+  }
+  return parsed.origin + (parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/$/, ""));
+}
+
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://xn--d1ah4a.com";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([1e3, 5e3, 3e4, 6e4, 9e4]);
+function requirePositive(value, name) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new ItdConfigError(`${name} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043E\u0442\u0440\u0438\u0446\u0430\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${value}`);
+  }
+  return value;
+}
+function consoleLogger() {
+  return {
+    debug: (message, ...args) => console.debug(`[itd-api] ${message}`, ...args),
+    info: (message, ...args) => console.info(`[itd-api] ${message}`, ...args),
+    warn: (message, ...args) => console.warn(`[itd-api] ${message}`, ...args),
+    error: (message, ...args) => console.error(`[itd-api] ${message}`, ...args)
+  };
+}
+function resolveRetry(retry) {
+  if (retry === false) return void 0;
+  const options = retry ?? {};
+  const attempts = options.attempts ?? 3;
+  if (!Number.isInteger(attempts) || attempts < 1) {
+    throw new ItdConfigError(`retry.attempts \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0446\u0435\u043B\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C \u043E\u0442 1, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${attempts}`);
+  }
+  const jitter = options.jitter ?? 0.3;
+  if (jitter < 0 || jitter > 1) {
+    throw new ItdConfigError(`retry.jitter \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0432 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D\u0435 0\u20261, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${jitter}`);
+  }
+  if (attempts === 1) return void 0;
+  return {
+    attempts,
+    baseDelay: requirePositive(options.baseDelay ?? 500, "retry.baseDelay"),
+    maxDelay: requirePositive(options.maxDelay ?? 3e4, "retry.maxDelay"),
+    jitter,
+    retryWrites: options.retryWrites ?? false,
+    shouldRetry: options.shouldRetry
+  };
+}
+function resolveRateLimit(rateLimit) {
+  if (rateLimit === false) return void 0;
+  const defaults = {
+    concurrency: 6,
+    rps: void 0,
+    retryDelays: DEFAULT_RATE_LIMIT_DELAYS,
+    respectHeaders: true
+  };
+  if (!rateLimit) return defaults;
+  const concurrency = rateLimit.concurrency ?? 6;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new ItdConfigError(
+      `rateLimit.concurrency \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0446\u0435\u043B\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C \u043E\u0442 1, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${concurrency}`
+    );
+  }
+  if (rateLimit.rps !== void 0 && (!Number.isFinite(rateLimit.rps) || rateLimit.rps <= 0)) {
+    throw new ItdConfigError(
+      `rateLimit.rps \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043F\u043E\u043B\u043E\u0436\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${rateLimit.rps}`
+    );
+  }
+  const retryDelays = rateLimit.retryDelays ?? defaults.retryDelays;
+  for (const delay of retryDelays) requirePositive(delay, "rateLimit.retryDelays");
+  return {
+    concurrency,
+    rps: rateLimit.rps,
+    retryDelays,
+    respectHeaders: rateLimit.respectHeaders ?? true
+  };
+}
+function validateAuth(auth) {
+  if (auth === void 0) return void 0;
+  if (typeof auth === "string") {
+    if (auth.trim() === "") {
+      throw new ItdConfigError("auth: \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u0430 \u043F\u0443\u0441\u0442\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430 \u0432\u043C\u0435\u0441\u0442\u043E accessToken");
+    }
+    return auth;
+  }
+  if (typeof auth !== "object" || auth === null) {
+    throw new ItdConfigError(
+      `auth \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0439 \u0441 \u0442\u043E\u043A\u0435\u043D\u043E\u043C \u0438\u043B\u0438 \u043E\u0431\u044A\u0435\u043A\u0442\u043E\u043C, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${typeof auth}`
+    );
+  }
+  if ("getToken" in auth) {
+    if (typeof auth.getToken !== "function") {
+      throw new ItdConfigError("auth.getToken \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0444\u0443\u043D\u043A\u0446\u0438\u0435\u0439");
+    }
+    return auth;
+  }
+  if ("accessToken" in auth) {
+    if (typeof auth.accessToken !== "string" || auth.accessToken.trim() === "") {
+      throw new ItdConfigError("auth.accessToken \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u043E\u0439");
+    }
+    return auth;
+  }
+  if ("email" in auth || "password" in auth) {
+    const { email, password } = auth;
+    if (typeof email !== "string" || email.trim() === "") {
+      throw new ItdConfigError("auth.email \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u043E\u0439");
+    }
+    if (typeof password !== "string" || password === "") {
+      throw new ItdConfigError("auth.password \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u043E\u0439");
+    }
+    return auth;
+  }
+  throw new ItdConfigError(
+    "auth \u043D\u0435 \u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D. \u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F \u0441\u0442\u0440\u043E\u043A\u0430 \u0441 accessToken \u043B\u0438\u0431\u043E \u043E\u0431\u044A\u0435\u043A\u0442 { accessToken }, { email, password } \u0438\u043B\u0438 { getToken }"
+  );
+}
+function resolveConfig(options = {}) {
+  const mode = options.mode ?? "auto";
+  if (mode !== "auto" && mode !== "browser" && mode !== "server") {
+    throw new ItdConfigError(`mode \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C 'auto', 'browser' \u0438\u043B\u0438 'server', \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E: ${mode}`);
+  }
+  const timeout = requirePositive(options.timeout ?? DEFAULT_TIMEOUT, "timeout");
+  return {
+    baseUrl: normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL),
+    auth: validateAuth(options.auth),
+    storage: options.storage ?? new MemoryTokenStorage(),
+    autoRefresh: options.autoRefresh ?? true,
+    reloginOnRefreshFailure: options.reloginOnRefreshFailure ?? true,
+    fetch: resolveFetch(options.fetch),
+    timeout,
+    retry: resolveRetry(options.retry),
+    rateLimit: resolveRateLimit(options.rateLimit),
+    hooks: options.hooks ?? {},
+    logger: options.logger === true ? consoleLogger() : options.logger || void 0,
+    headers: { ...options.headers },
+    mode,
+    useCookieJar: shouldUseCookieJar(mode),
+    sendCredentials: shouldSendCredentials(mode)
+  };
+}
+
+// src/core/error-factory.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function collectFieldErrors(source) {
+  const result = {};
+  const errors = source.errors;
+  if (isRecord(errors)) {
+    for (const [field, value] of Object.entries(errors)) {
+      if (Array.isArray(value)) {
+        const messages = value.filter((item) => typeof item === "string");
+        if (messages.length > 0) result[field] = messages;
+      } else if (typeof value === "string") {
+        result[field] = [value];
+      }
+    }
+  }
+  const violations = source.violations;
+  if (Array.isArray(violations)) {
+    for (const violation of violations) {
+      if (!isRecord(violation)) continue;
+      const field = asString(violation.field) ?? asString(violation.property);
+      const message = asString(violation.message);
+      if (!field || !message) continue;
+      const existing = result[field];
+      if (existing) existing.push(message);
+      else result[field] = [message];
+    }
+  }
+  return result;
+}
+function parseErrorBody(body, status, statusText = "") {
+  const fallbackMessage = statusText ? `HTTP ${status} ${statusText}` : `HTTP ${status}`;
+  if (typeof body === "string") {
+    return {
+      code: "UNKNOWN_ERROR",
+      message: asString(body.trim()) ?? fallbackMessage,
+      detail: void 0,
+      title: void 0,
+      fieldErrors: {},
+      userId: void 0
+    };
+  }
+  if (!isRecord(body)) {
+    return {
+      code: "UNKNOWN_ERROR",
+      message: fallbackMessage,
+      detail: void 0,
+      title: void 0,
+      fieldErrors: {},
+      userId: void 0
+    };
+  }
+  if (body.type === "validation") {
+    const target = asString(body.on);
+    return {
+      code: "VALIDATION_ERROR",
+      message: target ? `\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u043D\u0435 \u043F\u0440\u043E\u0439\u0434\u0435\u043D\u0430: \u043D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u0432 \xAB${target}\xBB` : "\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u0432\u0445\u043E\u0434\u043D\u044B\u0445 \u0434\u0430\u043D\u043D\u044B\u0445 \u043D\u0435 \u043F\u0440\u043E\u0439\u0434\u0435\u043D\u0430",
+      detail: void 0,
+      title: void 0,
+      fieldErrors: {},
+      userId: void 0
+    };
+  }
+  const inner = isRecord(body.error) ? body.error : body;
+  const message = asString(inner.message) ?? asString(inner.detail) ?? asString(inner.title) ?? // `{ "error": "Invalid token" }` — так отвечает сервер на недействительный токен.
+  asString(body.error) ?? fallbackMessage;
+  return {
+    code: asString(inner.code) ?? asString(body.code) ?? "UNKNOWN_ERROR",
+    message,
+    detail: asString(inner.detail),
+    title: asString(inner.title),
+    fieldErrors: { ...collectFieldErrors(body), ...collectFieldErrors(inner) },
+    userId: asString(inner.userId) ?? asString(body.userId)
+  };
+}
+function parseRetryAfter(header, now = Date.now()) {
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(header);
+  if (Number.isFinite(date)) return Math.max(0, date - now);
+  return void 0;
+}
+function readIntHeader(headers, name) {
+  const raw = headers?.get(name);
+  if (raw === null || raw === void 0) return void 0;
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) ? value : void 0;
+}
+function readRateLimit(headers) {
+  return {
+    limit: readIntHeader(headers, "x-ratelimit-limit"),
+    remaining: readIntHeader(headers, "x-ratelimit-remaining")
+  };
+}
+var REQUEST_ID_HEADERS = ["x-request-id", "x-requestid", "request-id", "x-correlation-id"];
+function getRequestId(headers) {
+  if (!headers) return void 0;
+  for (const name of REQUEST_ID_HEADERS) {
+    const value = headers.get(name);
+    if (value) return value;
+  }
+  return void 0;
+}
+var CODE_TO_CLASS = {
+  VALIDATION_ERROR: ItdValidationError,
+  RATE_LIMIT_EXCEEDED: ItdRateLimitError,
+  UNAUTHORIZED: ItdAuthError,
+  SESSION_EXPIRED: ItdAuthError,
+  SESSION_REVOKED: ItdAuthError,
+  SESSION_INVALID_REFRESH_TOKEN: ItdAuthError,
+  ACCOUNT_INVALID_CREDENTIALS: ItdAuthError,
+  ACCESS_DENIED: ItdForbiddenError,
+  ENTITY_NOT_FOUND: ItdNotFoundError,
+  // Сервер отвечает именно так: `{ error: { code: 'NOT_FOUND', message: 'Post not found' } }`.
+  NOT_FOUND: ItdNotFoundError,
+  ENTITY_ALREADY_EXISTS: ItdConflictError
+};
+function classByStatus(status) {
+  if (status === 401) return ItdAuthError;
+  if (status === 403) return ItdForbiddenError;
+  if (status === 404) return ItdNotFoundError;
+  if (status === 409) return ItdConflictError;
+  if (status === 422) return ItdValidationError;
+  if (status === 429) return ItdRateLimitError;
+  if (status >= 500) return ItdServerError;
+  return ItdApiError;
+}
+function createApiError(context) {
+  const parsed = parseErrorBody(context.body, context.status, context.statusText);
+  const rateLimit = readRateLimit(context.headers);
+  const init = {
+    rateLimit: rateLimit.limit,
+    rateLimitRemaining: rateLimit.remaining,
+    status: context.status,
+    code: parsed.code,
+    message: parsed.message,
+    detail: parsed.detail,
+    title: parsed.title,
+    fieldErrors: parsed.fieldErrors,
+    requestId: getRequestId(context.headers),
+    method: context.method,
+    path: context.path,
+    raw: context.body,
+    response: context.response,
+    retryAfter: parseRetryAfter(context.headers?.get("retry-after"))
+  };
+  if (parsed.code === "PHONE_VERIFICATION_REQUIRED") {
+    return new ItdPhoneVerificationError({ ...init, userId: parsed.userId });
+  }
+  const Ctor = CODE_TO_CLASS[parsed.code] ?? classByStatus(context.status);
+  return new Ctor(init);
+}
+
+// src/core/redact.ts
+var SECRET_HEADERS = /* @__PURE__ */ new Set(["authorization", "cookie", "set-cookie", "x-api-key"]);
+var SECRET_FIELDS = /* @__PURE__ */ new Set([
+  "password",
+  "oldpassword",
+  "newpassword",
+  "accesstoken",
+  "refreshtoken",
+  "flowtoken",
+  "token",
+  "otp"
+]);
+function maskSecret(value) {
+  if (value.length <= 8) return "\u2026";
+  return `${value.slice(0, 4)}\u2026(${value.length})\u2026${value.slice(-3)}`;
+}
+function redactHeaders(headers) {
+  const result = {};
+  headers.forEach((value, name) => {
+    if (SECRET_HEADERS.has(name.toLowerCase())) {
+      const spaceAt = value.indexOf(" ");
+      result[name] = spaceAt > 0 ? `${value.slice(0, spaceAt)} ${maskSecret(value.slice(spaceAt + 1))}` : maskSecret(value);
+      return;
+    }
+    result[name] = value;
+  });
+  return result;
+}
+function redactBody(body) {
+  if (body === null || body === void 0) return body;
+  if (typeof FormData !== "undefined" && body instanceof FormData) return "[FormData]";
+  if (typeof Blob !== "undefined" && body instanceof Blob) return "[Blob]";
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return "[binary]";
+  if (Array.isArray(body)) return body.map(redactBody);
+  if (typeof body === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(body)) {
+      result[key] = SECRET_FIELDS.has(key.toLowerCase()) ? "[\u0441\u043A\u0440\u044B\u0442\u043E]" : redactBody(value);
+    }
+    return result;
+  }
+  return body;
+}
+
+// src/core/unwrap.ts
+function unwrapData(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return body;
+  const keys = Object.keys(body);
+  if (keys.length !== 1 || keys[0] !== "data") return body;
+  return body.data;
+}
+function pickArray(source, field) {
+  if (typeof source !== "object" || source === null) return [];
+  const value = source[field];
+  return Array.isArray(value) ? value : [];
+}
+function pickObject(source, field) {
+  if (typeof source !== "object" || source === null) return void 0;
+  const value = source[field];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+function pickBoolean(source, field, fallback = false) {
+  if (typeof source !== "object" || source === null) return fallback;
+  const value = source[field];
+  return typeof value === "boolean" ? value : fallback;
+}
+function pickNumber(source, field, fallback) {
+  if (typeof source !== "object" || source === null) return fallback;
+  const value = source[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function pickString(source, field) {
+  if (typeof source !== "object" || source === null) return void 0;
+  const value = source[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/core/http.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function setHeader(headers, name, value) {
+  try {
+    headers.set(name, value);
+  } catch {
+    throw new ItdConfigError(
+      `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0430 ${name} \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u0442 \u0441\u0438\u043C\u0432\u043E\u043B\u044B \u0432\u043D\u0435 latin1. HTTP-\u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0438 \u043D\u0435 \u043C\u043E\u0433\u0443\u0442 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C \u043A\u0438\u0440\u0438\u043B\u043B\u0438\u0446\u0443 \u2014 \u0437\u0430\u043A\u043E\u0434\u0438\u0440\u0443\u0439\u0442\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 \u0447\u0435\u0440\u0435\u0437 encodeURIComponent.`
+    );
+  }
+}
+function isRawBody(body) {
+  if (typeof body !== "object" || body === null) return typeof body === "string";
+  return typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+async function readBody(response) {
+  if (response.status === 204 || response.status === 205) return void 0;
+  if (response.headers.get("content-length") === "0") return void 0;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("json")) {
+    const text2 = await response.text();
+    if (text2 === "") return void 0;
+    try {
+      return JSON.parse(text2);
+    } catch {
+      return text2;
+    }
+  }
+  const text = await response.text();
+  return text === "" ? void 0 : text;
+}
+function createAbortBundle(userSignal, timeout) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onUserAbort = () => controller.abort(userSignal?.reason);
+  if (userSignal) {
+    if (userSignal.aborted) controller.abort(userSignal.reason);
+    else userSignal.addEventListener("abort", onUserAbort, { once: true });
+  }
+  const timer = timeout > 0 ? setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeout) : void 0;
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    cleanup: () => {
+      if (timer !== void 0) clearTimeout(timer);
+      userSignal?.removeEventListener("abort", onUserAbort);
+    }
+  };
+}
+var HttpClient = class {
+  #config;
+  #collaborators;
+  constructor(config, collaborators = {}) {
+    this.#config = config;
+    this.#collaborators = collaborators;
+  }
+  /** Базовый URL, к которому обращается клиент. */
+  get baseUrl() {
+    return this.#config.baseUrl;
+  }
+  /**
+   * Подключает недостающие части конвейера.
+   *
+   * Нужно из-за кольцевой зависимости: слой авторизации сам выполняет запросы, поэтому
+   * не может быть передан в конструктор до создания транспорта.
+   */
+  setCollaborators(collaborators) {
+    this.#collaborators = { ...this.#collaborators, ...collaborators };
+  }
+  /**
+   * Выполняет запрос к API.
+   *
+   * @typeParam T ожидаемая форма ответа после снятия обёртки `{ data: … }`
+   * @throws {ItdApiError} если сервер ответил статусом ≥ 400
+   * @throws {ItdTimeoutError} если истёк таймаут
+   * @throws {ItdAbortError} если запрос отменён через `signal`
+   * @throws {ItdNetworkError} если запрос не дошёл до сервера
+   */
+  async request(options) {
+    const task = () => this.#withRetries(options);
+    return this.#collaborators.schedule ? this.#collaborators.schedule(task) : task();
+  }
+  async #withRetries(options) {
+    const method = options.method.toUpperCase();
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await this.#attempt(options, attempt);
+      } catch (error) {
+        const delay = this.#collaborators.nextRetryDelay?.(error, attempt, method);
+        if (delay === void 0) throw error;
+        await this.#config.hooks.onRetry?.({
+          method,
+          path: options.path,
+          url: this.#buildUrl(options),
+          headers: new Headers(),
+          attempt,
+          error,
+          delay
+        });
+        this.#config.logger?.debug(
+          `\u043F\u043E\u0432\u0442\u043E\u0440 ${method} ${options.path}, \u043F\u043E\u043F\u044B\u0442\u043A\u0430 ${attempt + 1} \u0447\u0435\u0440\u0435\u0437 ${delay} \u043C\u0441`
+        );
+        await sleep(delay);
+      }
+    }
+  }
+  #buildUrl(options) {
+    return joinUrl(this.#config.baseUrl, options.path) + buildQuery(options.query);
+  }
+  async #buildHeaders(options, url) {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    for (const [name, value] of Object.entries(this.#config.headers))
+      setHeader(headers, name, value);
+    if (!options.skipAuth && this.#collaborators.getAuthHeaders) {
+      const auth = await this.#collaborators.getAuthHeaders();
+      for (const [name, value] of Object.entries(auth)) setHeader(headers, name, value);
+    }
+    if (this.#config.useCookieJar && this.#collaborators.getCookieHeader) {
+      const cookie = this.#collaborators.getCookieHeader(url);
+      if (cookie) setHeader(headers, "Cookie", cookie);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+      setHeader(headers, name, value);
+    }
+    return headers;
+  }
+  async #attempt(options, attempt) {
+    const method = options.method.toUpperCase();
+    const url = this.#buildUrl(options);
+    const headers = await this.#buildHeaders(options, url);
+    let body;
+    if (options.body !== void 0 && options.body !== null) {
+      if (isRawBody(options.body)) {
+        body = options.body;
+      } else {
+        body = JSON.stringify(options.body);
+        if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+      }
+    }
+    const context = { method, path: options.path, url, headers, attempt };
+    await this.#config.hooks.onRequest?.(context);
+    const timeout = options.timeout ?? this.#config.timeout;
+    const abort = createAbortBundle(options.signal, timeout);
+    const startedAt = Date.now();
+    this.#config.logger?.debug(`\u2192 ${method} ${options.path}`, {
+      headers: redactHeaders(headers),
+      body: redactBody(options.body)
+    });
+    let response;
+    try {
+      response = await this.#config.fetch(url, {
+        method,
+        headers,
+        signal: abort.signal,
+        ...body !== void 0 ? { body } : {},
+        ...this.#config.sendCredentials ? { credentials: "include" } : {}
+      });
+    } catch (error) {
+      const duration2 = Date.now() - startedAt;
+      const failure = this.#toTransportError(error, abort, options, method, timeout);
+      await this.#config.hooks.onError?.({ ...context, duration: duration2, error: failure });
+      this.#config.logger?.warn(`\xD7 ${method} ${options.path} (${duration2} \u043C\u0441): ${failure.message}`);
+      throw failure;
+    } finally {
+      abort.cleanup();
+    }
+    const duration = Date.now() - startedAt;
+    if (this.#collaborators.onRateLimit) {
+      const { limit, remaining } = readRateLimit(response.headers);
+      this.#collaborators.onRateLimit(limit, remaining);
+    }
+    if (this.#config.useCookieJar) this.#collaborators.saveCookies?.(url, response);
+    const payload = await readBody(response);
+    if (!response.ok) {
+      if (response.status === 401 && !options.skipAuthRefresh && this.#config.autoRefresh && this.#collaborators.onUnauthorized) {
+        const refreshed = await this.#collaborators.onUnauthorized();
+        if (refreshed) {
+          this.#config.logger?.debug(`\u0442\u043E\u043A\u0435\u043D \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D, \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u044E ${method} ${options.path}`);
+          return this.#attempt({ ...options, skipAuthRefresh: true }, attempt);
+        }
+      }
+      const error = createApiError({
+        method,
+        path: options.path,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        response,
+        body: payload
+      });
+      await this.#config.hooks.onError?.({ ...context, duration, error });
+      this.#config.logger?.warn(
+        `\u2190 ${response.status} ${method} ${options.path} (${duration} \u043C\u0441): ${error.message}`
+      );
+      throw error;
+    }
+    await this.#config.hooks.onResponse?.({
+      ...context,
+      status: response.status,
+      duration,
+      response
+    });
+    this.#config.logger?.debug(`\u2190 ${response.status} ${method} ${options.path} (${duration} \u043C\u0441)`);
+    return options.raw ? payload : unwrapData(payload);
+  }
+  /** Превращает исключение `fetch` в понятную ошибку библиотеки. */
+  #toTransportError(error, abort, options, method, timeout) {
+    const aborted = error instanceof Error && error.name === "AbortError";
+    if (aborted && abort.timedOut()) {
+      return new ItdTimeoutError({ timeout, method, path: options.path });
+    }
+    if (aborted) {
+      return new ItdAbortError(`\u0417\u0430\u043F\u0440\u043E\u0441 ${method} ${options.path} \u043E\u0442\u043C\u0435\u043D\u0451\u043D`);
+    }
+    return new ItdNetworkError(
+      `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C ${method} ${options.path}: ${error instanceof Error ? error.message : String(error)}`,
+      { method, path: options.path, cause: error }
+    );
+  }
+};
+
+// src/core/rate-limit.ts
+var RequestQueue = class {
+  #concurrency;
+  /** Минимальный промежуток между стартами, мс. `0` — без ограничения частоты. */
+  #minGap;
+  #waiting = [];
+  #active = 0;
+  /** Момент, раньше которого следующий запрос стартовать не должен. */
+  #nextSlot = 0;
+  #timer;
+  constructor(options) {
+    this.#concurrency = options.concurrency;
+    this.#minGap = options.rps ? 1e3 / options.rps : 0;
+  }
+  /** Сколько задач выполняется прямо сейчас. */
+  get active() {
+    return this.#active;
+  }
+  /** Сколько задач ждёт очереди. */
+  get pending() {
+    return this.#waiting.length;
+  }
+  /**
+   * Ставит задачу в очередь.
+   *
+   * @returns результат задачи; ошибка задачи пробрасывается без изменений
+   */
+  schedule(task) {
+    return new Promise((resolve, reject) => {
+      const run = () => {
+        this.#active += 1;
+        task().then(resolve, reject).finally(() => {
+          this.#active -= 1;
+          this.#drain();
+        });
+      };
+      this.#waiting.push({ run });
+      this.#drain();
+    });
+  }
+  /**
+   * Придерживает всю очередь на заданное время.
+   *
+   * Вызывается при получении `429` с заголовком `Retry-After`: тормозить нужно все запросы,
+   * а не только тот, который наткнулся на лимит, — иначе остальные продолжат добивать API.
+   */
+  pause(ms) {
+    if (ms <= 0) return;
+    this.#nextSlot = Math.max(this.#nextSlot, Date.now() + ms);
+  }
+  /** Запускает столько ожидающих задач, сколько позволяют ограничения. */
+  #drain() {
+    if (this.#waiting.length === 0) return;
+    if (this.#active >= this.#concurrency) return;
+    if (this.#timer !== void 0) return;
+    const now = Date.now();
+    if (this.#nextSlot > now) {
+      this.#timer = setTimeout(() => {
+        this.#timer = void 0;
+        this.#drain();
+      }, this.#nextSlot - now);
+      return;
+    }
+    const next = this.#waiting.shift();
+    if (!next) return;
+    if (this.#minGap > 0) this.#nextSlot = now + this.#minGap;
+    next.run();
+    this.#drain();
+  }
+};
+
+// src/core/retry.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function isRetryable(error, method, retryWrites) {
+  if (error instanceof ItdAbortError) return false;
+  const safeToRepeat = retryWrites || IDEMPOTENT_METHODS.has(method);
+  if (error instanceof ItdApiError) {
+    if (error.status === 429) return true;
+    if (error.status >= 500) return safeToRepeat;
+    return false;
+  }
+  if (error instanceof ItdNetworkError || error instanceof ItdTimeoutError) return safeToRepeat;
+  return false;
+}
+function backoffDelay(attempt, options, random) {
+  const exponential = options.baseDelay * 2 ** (attempt - 1);
+  const capped = Math.min(exponential, options.maxDelay);
+  const spread = capped * options.jitter * (random() * 2 - 1);
+  return Math.max(0, Math.round(capped + spread));
+}
+function createRetryScheduler(options, random = Math.random) {
+  return (error, attempt, method) => {
+    if (attempt >= options.attempts) return void 0;
+    if (options.shouldRetry) {
+      return options.shouldRetry(error, attempt) ? backoffDelay(attempt, options, random) : void 0;
+    }
+    if (!isRetryable(error, method, options.retryWrites)) return void 0;
+    if (error instanceof ItdApiError && error.retryAfter !== void 0) {
+      return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
+    }
+    return backoffDelay(attempt, options, random);
+  };
+}
+
+// src/notifications/type-map.ts
+var NOTIFICATION_TYPE_ALIASES = Object.freeze({
+  like: NotificationType.PostReaction,
+  comment: NotificationType.PostComment,
+  comment_like: NotificationType.CommentReaction,
+  reply: NotificationType.CommentReply,
+  repost: NotificationType.PostRepost,
+  mention: NotificationType.PostMention
+});
+var KNOWN_TYPES = new Set(Object.values(NotificationType));
+function canonicalNotificationType(rawType) {
+  return NOTIFICATION_TYPE_ALIASES[rawType] ?? rawType;
+}
+function isKnownNotificationType(type) {
+  return KNOWN_TYPES.has(canonicalNotificationType(type));
+}
+
+// src/notifications/normalize.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asActor(value) {
+  if (!isRecord2(value)) return void 0;
+  const id = asString2(value.id);
+  if (!id) return void 0;
+  return {
+    id,
+    username: asString2(value.username) ?? "",
+    displayName: asString2(value.displayName) ?? "",
+    avatar: asString2(value.avatar) ?? "",
+    ...typeof value.isFollowing === "boolean" ? { isFollowing: value.isFollowing } : {},
+    ...typeof value.isFollowedBy === "boolean" ? { isFollowedBy: value.isFollowedBy } : {}
+  };
+}
+function readActors(source) {
+  if (Array.isArray(source.actors)) {
+    return source.actors.map(asActor).filter((actor) => actor !== void 0);
+  }
+  const single = asActor(source.actor);
+  return single ? [single] : [];
+}
+function normalizeNotification(input) {
+  const source = isRecord2(input) ? input : {};
+  const payload = isRecord2(source.payload) ? source.payload : source;
+  const rawType = asString2(payload.type) ?? asString2(source.type) ?? "";
+  const createdAt = asString2(payload.createdAt) ?? asString2(source.createdAt) ?? "";
+  const readAt = asString2(payload.readAt) ?? asString2(source.readAt);
+  const isRead = typeof payload.isRead === "boolean" ? payload.isRead : typeof payload.read === "boolean" ? payload.read : Boolean(readAt);
+  const subjectId = asString2(payload.subjectId);
+  const targetId = asString2(payload.targetId);
+  const subjectIsComment = payload.subjectType === "comment";
+  return {
+    id: asString2(payload.id) ?? asString2(source.id) ?? "",
+    type: canonicalNotificationType(rawType),
+    rawType,
+    entityId: asString2(payload.entityId) ?? (subjectIsComment ? subjectId ?? targetId : targetId) ?? null,
+    parentEntityId: asString2(payload.parentEntityId) ?? (subjectIsComment ? targetId ?? null : null),
+    isRead,
+    actors: readActors(payload),
+    count: typeof payload.count === "number" && payload.count > 0 ? payload.count : 1,
+    preview: asString2(payload.entityPreview) ?? asString2(payload.preview) ?? null,
+    ...asString2(payload.clickUrl) ? { clickUrl: asString2(payload.clickUrl) } : {},
+    createdAt,
+    updatedAt: asString2(payload.updatedAt) ?? readAt ?? createdAt,
+    raw: input
+  };
+}
+function readNotificationEvent(data) {
+  const source = isRecord2(data) ? data : {};
+  return {
+    notification: normalizeNotification(data),
+    unreadCount: typeof source.unreadCount === "number" ? source.unreadCount : void 0,
+    sound: source.sound === true
+  };
+}
+function readUnreadCountEvent(data) {
+  if (!isRecord2(data)) return void 0;
+  const payload = isRecord2(data.payload) ? data.payload : void 0;
+  if (!payload) return void 0;
+  return typeof payload.count === "number" ? payload.count : void 0;
+}
+
+// src/realtime/transport.ts
+var UnauthorizedStreamError = class extends Error {
+  constructor() {
+    super("\u041F\u043E\u0442\u043E\u043A \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0439 \u043E\u0442\u0432\u0435\u0440\u0433 \u0442\u043E\u043A\u0435\u043D \u0434\u043E\u0441\u0442\u0443\u043F\u0430");
+    this.name = "UnauthorizedStreamError";
+  }
+};
+
+// src/realtime/poll.ts
+var PollTransport = class {
+  name = "poll";
+  #interval;
+  #limit;
+  constructor(options = {}) {
+    this.#interval = options.interval ?? 15e3;
+    this.#limit = options.limit ?? 20;
+  }
+  async connect(context) {
+    const seen = /* @__PURE__ */ new Set();
+    let firstRun = true;
+    let lastUnreadCount;
+    context.onOpen();
+    while (!context.signal.aborted) {
+      const token = await context.getToken();
+      if (!token) throw new UnauthorizedStreamError();
+      const headers = new Headers({
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`
+      });
+      const response = await context.fetch(
+        `${joinUrl(context.baseUrl, "/api/notifications/")}?limit=${this.#limit}&offset=0`,
+        { method: "GET", headers, signal: context.signal }
+      );
+      if (response.status === 401) throw new UnauthorizedStreamError();
+      if (!response.ok) throw new Error(`\u041E\u043F\u0440\u043E\u0441 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0439 \u0432\u0435\u0440\u043D\u0443\u043B \u0441\u0442\u0430\u0442\u0443\u0441 ${response.status}`);
+      const body = await response.json();
+      const payload = typeof body === "object" && body !== null && "data" in body ? body.data : body;
+      const items = pickArray(payload, "notifications");
+      for (const item of [...items].reverse()) {
+        const id = typeof item.id === "string" ? item.id : void 0;
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        if (!firstRun) context.onEvent({ name: "notification", data: { payload: item } });
+      }
+      if (seen.size > this.#limit * 2) {
+        const excess = [...seen].slice(0, seen.size - this.#limit * 2);
+        for (const id of excess) seen.delete(id);
+      }
+      const count = await this.#readCount(context, headers);
+      if (count !== void 0 && count !== lastUnreadCount) {
+        lastUnreadCount = count;
+        context.onEvent({ name: "unread_count", data: { payload: { count } } });
+      }
+      firstRun = false;
+      await this.#wait(context.signal);
+    }
+  }
+  async #readCount(context, headers) {
+    try {
+      const response = await context.fetch(joinUrl(context.baseUrl, "/api/notifications/count"), {
+        method: "GET",
+        headers,
+        signal: context.signal
+      });
+      if (!response.ok) return void 0;
+      const body = await response.json();
+      const payload = typeof body === "object" && body !== null && "data" in body ? body.data : body;
+      return pickNumber(payload, "count", 0);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Ждёт следующего опроса, прерываясь при отмене. */
+  #wait(signal) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(finish, this.#interval);
+      function finish() {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", finish);
+        resolve();
+      }
+      signal.addEventListener("abort", finish, { once: true });
+    });
+  }
+};
+
+// src/realtime/reconnect.ts
+var RECONNECT_BACKOFF = Object.freeze([1e3, 2e3, 4e3, 8e3, 16e3, 3e4]);
+var RECONNECT_JITTER = 0.3;
+var MAX_RECONNECT_ATTEMPTS = 15;
+function reconnectDelay(attempt, options = {}, random = Math.random) {
+  const backoff = options.backoff ?? RECONNECT_BACKOFF;
+  const jitter = options.jitter ?? RECONNECT_JITTER;
+  const base = backoff[Math.min(attempt, backoff.length - 1)] ?? 3e4;
+  const spread = base * jitter * (random() * 2 - 1);
+  return Math.max(0, Math.round(base + spread));
+}
+
+// node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start2, end) {
+    if (start2 === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start2);
+    if (isDataPrefix(chunk, start2, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start2 + 5) === SPACE ? start2 + 6 : start2 + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start2, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start2 + 6) === SPACE ? start2 + 7 : start2 + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start2 + 1) === 100 && chunk.charCodeAt(start2 + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start2 + 3) === SPACE ? start2 + 4 : start2 + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start2, end);
+        onComment(line2.slice(chunk.charCodeAt(start2 + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start2, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// src/realtime/sse.ts
+var STREAM_PATH = "/api/notifications/stream";
+var SseTransport = class {
+  name = "sse";
+  #idleTimeout;
+  /** Идентификатор последнего события — отправляется при переподключении. */
+  #lastEventId;
+  constructor(options = {}) {
+    this.#idleTimeout = options.idleTimeout ?? 9e4;
+  }
+  async connect(context) {
+    const token = await context.getToken();
+    if (!token) throw new UnauthorizedStreamError();
+    const headers = new Headers({
+      Accept: "text/event-stream",
+      Authorization: `Bearer ${token}`,
+      "Cache-Control": "no-cache"
+    });
+    if (this.#lastEventId) headers.set("Last-Event-ID", this.#lastEventId);
+    const response = await context.fetch(joinUrl(context.baseUrl, STREAM_PATH), {
+      method: "GET",
+      headers,
+      signal: context.signal
+    });
+    if (response.status === 401) throw new UnauthorizedStreamError();
+    if (!response.ok) throw new Error(`\u041F\u043E\u0442\u043E\u043A \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0439 \u0432\u0435\u0440\u043D\u0443\u043B \u0441\u0442\u0430\u0442\u0443\u0441 ${response.status}`);
+    if (!response.body) throw new Error("\u041E\u0442\u0432\u0435\u0442 \u043F\u043E\u0442\u043E\u043A\u0430 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0439 \u043F\u0443\u0441\u0442");
+    context.onOpen();
+    await this.#read(response.body, context);
+  }
+  async #read(body, context) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const parser = createParser({
+      onEvent: (message) => {
+        if (message.id) this.#lastEventId = message.id;
+        let data;
+        try {
+          data = JSON.parse(message.data);
+        } catch (error) {
+          context.onParseError(error, message.data);
+          return;
+        }
+        const name = message.event ?? (typeof data === "object" && data !== null && "type" in data ? String(data.type) : "message");
+        context.onEvent({ name, data });
+      }
+    });
+    let idleTimer;
+    const armIdleTimer = () => {
+      if (this.#idleTimeout <= 0) return;
+      if (idleTimer !== void 0) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        void reader.cancel(new Error("\u041F\u043E\u0442\u043E\u043A \u043C\u043E\u043B\u0447\u0438\u0442 \u0434\u043E\u043B\u044C\u0448\u0435 \u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u043E\u0433\u043E")).catch(() => {
+        });
+      }, this.#idleTimeout);
+    };
+    armIdleTimer();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        armIdleTimer();
+        parser.feed(decoder.decode(value, { stream: true }));
+      }
+    } finally {
+      if (idleTimer !== void 0) clearTimeout(idleTimer);
+      reader.releaseLock?.();
+    }
+  }
+};
+
+// src/realtime/stream.ts
+var ItdRealtime = class {
+  #deps;
+  #options;
+  #emitter = new Emitter();
+  #transport;
+  #maxAttempts;
+  #controller;
+  #status = RealtimeStatus.Disconnected;
+  #attempt = 0;
+  #timer;
+  #detachEnvironment;
+  constructor(deps, options = {}) {
+    this.#deps = deps;
+    this.#options = options;
+    this.#maxAttempts = options.maxAttempts ?? MAX_RECONNECT_ATTEMPTS;
+    this.#transport = this.#createTransport();
+  }
+  /** Текущее состояние соединения. */
+  get status() {
+    return this.#status;
+  }
+  /** Какой транспорт используется: `sse` или `poll`. */
+  get transport() {
+    return this.#transport.name;
+  }
+  /** Подписывается на событие потока. @returns функция отписки */
+  on(event, listener) {
+    return this.#emitter.on(event, listener);
+  }
+  /** Подписывается на одно срабатывание. */
+  once(event, listener) {
+    return this.#emitter.once(event, listener);
+  }
+  /**
+   * Поднимает соединение.
+   *
+   * Повторный вызов при уже живом соединении ничего не делает — это защита от двойного
+   * подключения при перерисовке интерфейса.
+   *
+   * Возвращает управление сразу после запуска: соединение живёт в фоне.
+   */
+  async connect() {
+    if (this.#controller) return;
+    this.#attachEnvironmentListeners();
+    if (this.#options.syncCount !== false) {
+      try {
+        this.#emitter.emit("unreadCount", await this.#deps.fetchUnreadCount());
+      } catch (error) {
+        this.#deps.logger?.debug("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C \u0447\u0438\u0441\u043B\u043E \u043D\u0435\u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D\u043D\u044B\u0445", error);
+      }
+    }
+    this.#run();
+  }
+  /** Закрывает соединение и отменяет запланированные попытки. */
+  disconnect() {
+    if (this.#timer !== void 0) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    this.#detachEnvironment?.();
+    this.#detachEnvironment = void 0;
+    this.#controller?.abort();
+    this.#controller = void 0;
+    this.#attempt = 0;
+    this.#setStatus(RealtimeStatus.Disconnected);
+  }
+  /** Снимает все подписки. Соединение при этом не закрывается. */
+  removeAllListeners() {
+    this.#emitter.removeAllListeners();
+  }
+  #createTransport() {
+    const kind = this.#options.transport ?? "auto";
+    if (typeof kind === "object") return kind;
+    if (kind === "poll" || kind === "auto" && !supportsStreamingBody()) {
+      return new PollTransport({
+        ...this.#options.pollInterval !== void 0 ? { interval: this.#options.pollInterval } : {}
+      });
+    }
+    return new SseTransport({
+      ...this.#options.idleTimeout !== void 0 ? { idleTimeout: this.#options.idleTimeout } : {}
+    });
+  }
+  /** Запускает попытку подключения; повторы планирует сам. */
+  #run() {
+    const controller = new AbortController();
+    this.#controller = controller;
+    this.#setStatus(RealtimeStatus.Connecting);
+    void this.#transport.connect({
+      baseUrl: this.#deps.baseUrl,
+      fetch: this.#deps.fetch,
+      getToken: this.#deps.getToken,
+      signal: controller.signal,
+      onOpen: () => {
+        this.#attempt = 0;
+        this.#setStatus(RealtimeStatus.Connected);
+      },
+      onEvent: (event) => this.#handleEvent(event.name, event.data),
+      onParseError: (error, raw) => this.#emitter.emit("parseError", { error, raw })
+    }).then(
+      () => {
+        if (!controller.signal.aborted) {
+          this.#handleFailure(new Error("\u0421\u043E\u0435\u0434\u0438\u043D\u0435\u043D\u0438\u0435 \u0441 \u043F\u043E\u0442\u043E\u043A\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0439 \u0437\u0430\u043A\u0440\u044B\u0442\u043E"));
+        }
+      },
+      (error) => {
+        if (controller.signal.aborted) return;
+        this.#handleFailure(error);
+      }
+    );
+  }
+  #handleEvent(name, data) {
+    this.#emitter.emit("message", { name, data });
+    if (name === "connected") {
+      const userId = typeof data === "object" && data !== null && "userId" in data ? String(data.userId) : void 0;
+      this.#emitter.emit("ready", { userId });
+      return;
+    }
+    if (name === "notification") {
+      const event = readNotificationEvent(data);
+      this.#emitter.emit("notification", event);
+      if (event.unreadCount !== void 0) this.#emitter.emit("unreadCount", event.unreadCount);
+      return;
+    }
+    if (name === "unread_count") {
+      const count = readUnreadCountEvent(data);
+      if (count !== void 0) this.#emitter.emit("unreadCount", count);
+    }
+  }
+  #handleFailure(error) {
+    this.#controller = void 0;
+    if (error instanceof UnauthorizedStreamError) {
+      void this.#refreshAndReconnect(error);
+      return;
+    }
+    this.#setStatus(RealtimeStatus.Error);
+    this.#scheduleReconnect(error);
+  }
+  /** Обновляет токен и переподключается; при неудаче прекращает попытки. */
+  async #refreshAndReconnect(error) {
+    this.#setStatus(RealtimeStatus.Error);
+    const refreshed = await this.#deps.refresh().catch(() => false);
+    if (!refreshed) {
+      this.#emitter.emit("error", { error, willReconnect: false });
+      this.#emitter.emit("giveup", void 0);
+      return;
+    }
+    this.#scheduleReconnect(error);
+  }
+  #scheduleReconnect(error) {
+    if (this.#attempt >= this.#maxAttempts) {
+      this.#emitter.emit("error", { error, willReconnect: false });
+      this.#emitter.emit("giveup", void 0);
+      return;
+    }
+    const delay = reconnectDelay(this.#attempt, this.#options);
+    this.#attempt += 1;
+    this.#emitter.emit("error", { error, willReconnect: true });
+    this.#emitter.emit("reconnect", { attempt: this.#attempt, delay });
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      this.#run();
+    }, delay);
+  }
+  /**
+   * Подписывается на события среды.
+   *
+   * Возврат вкладки из фона и восстановление сети — самые частые причины «мёртвого»
+   * соединения. У сайта итд.com такой обработки нет.
+   */
+  #attachEnvironmentListeners() {
+    if (this.#detachEnvironment) return;
+    const target = globalThis;
+    if (typeof target.addEventListener !== "function") return;
+    const wake = () => {
+      if (this.#controller || this.#timer !== void 0) return;
+      if (this.#status === RealtimeStatus.Disconnected) return;
+      this.#attempt = 0;
+      this.#run();
+    };
+    const onVisibility = () => {
+      if (target.document?.visibilityState === "visible") wake();
+    };
+    const listeners = [];
+    if (this.#options.reconnectOnVisible !== false && target.document) {
+      listeners.push(["visibilitychange", onVisibility]);
+    }
+    if (this.#options.reconnectOnOnline !== false) {
+      listeners.push(["online", wake]);
+    }
+    for (const [type, listener] of listeners) target.addEventListener(type, listener);
+    this.#detachEnvironment = () => {
+      for (const [type, listener] of listeners) target.removeEventListener?.(type, listener);
+    };
+  }
+  #setStatus(status) {
+    if (this.#status === status) return;
+    this.#status = status;
+    this.#emitter.emit("status", status);
+  }
+};
+
+// src/core/pagination.ts
+function readItems(body, fields) {
+  if (Array.isArray(body)) return body;
+  for (const field of fields) {
+    const items = pickArray(body, field);
+    if (items.length > 0) return items;
+  }
+  return fields.length > 0 ? pickArray(body, fields[0]) : [];
+}
+function readCursor(body) {
+  const pagination = pickObject(body, "pagination");
+  const meta = pickObject(body, "meta");
+  const metaCursor = pickObject(meta, "cursor");
+  return pickString(pagination, "nextCursor") ?? pickString(body, "nextCursor") ?? pickString(body, "cursor") ?? pickString(metaCursor, "next") ?? null;
+}
+function readCursorPage(body, ...fields) {
+  const pagination = pickObject(body, "pagination");
+  const items = readItems(body, fields);
+  const nextCursor = readCursor(body);
+  return {
+    items,
+    // Если признака продолжения нет, ориентируемся на наличие курсора.
+    hasMore: pickBoolean(pagination, "hasMore", pickBoolean(body, "hasMore", nextCursor !== null)),
+    nextCursor,
+    limit: pickNumber(pagination, "limit", 0) || void 0,
+    raw: body
+  };
+}
+function readFlatCursorPage(body, ...fields) {
+  const items = readItems(body, fields);
+  const nextCursor = readCursor(body);
+  const total = pickNumber(body, "total", -1);
+  return {
+    items,
+    hasMore: pickBoolean(body, "hasMore", nextCursor !== null),
+    nextCursor,
+    ...total >= 0 ? { total } : {},
+    raw: body
+  };
+}
+function readPagedPage(body, ...fields) {
+  const pagination = pickObject(body, "pagination");
+  const items = readItems(body, fields);
+  const nextCursor = readCursor(body);
+  return {
+    items,
+    hasMore: pickBoolean(pagination, "hasMore", pickBoolean(body, "hasMore", nextCursor !== null)),
+    page: pickNumber(pagination, "page", 1),
+    limit: pickNumber(pagination, "limit", 0) || void 0,
+    total: pickNumber(pagination, "total", 0),
+    ...nextCursor !== null ? { nextCursor } : {},
+    raw: body
+  };
+}
+function readOffsetPage(body, field, offset) {
+  const items = pickArray(body, field);
+  return {
+    items,
+    hasMore: pickBoolean(body, "hasMore"),
+    nextOffset: offset + items.length,
+    raw: body
+  };
+}
+var Paginator = class {
+  #options;
+  #maxPages;
+  #state = {};
+  #finished = false;
+  #pagesLoaded = 0;
+  constructor(options) {
+    this.#options = options;
+    this.#maxPages = options.maxPages ?? 1e3;
+  }
+  /**
+   * Загружает следующую страницу.
+   *
+   * @returns страница либо `null`, если перебор закончен
+   */
+  async next() {
+    if (this.#finished) return null;
+    if (this.#options.signal?.aborted) return null;
+    if (this.#pagesLoaded >= this.#maxPages) {
+      this.#finished = true;
+      return null;
+    }
+    const previous = this.#state;
+    const page = await this.#options.load(previous);
+    this.#pagesLoaded += 1;
+    this.#state = this.#advance(previous, page);
+    return page;
+  }
+  /**
+   * Перебирает страницы целиком.
+   *
+   * Полезно, когда нужны сведения о самой странице — например `total`.
+   */
+  async *pages() {
+    for (; ; ) {
+      const page = await this.next();
+      if (!page) return;
+      yield page;
+    }
+  }
+  /** Перебирает элементы всех страниц подряд. */
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.pages()) {
+      for (const item of page.items) {
+        if (this.#options.signal?.aborted) return;
+        yield item;
+      }
+    }
+  }
+  /**
+   * Собирает элементы в массив.
+   *
+   * @param max сколько элементов достаточно; без него перебираются все страницы
+   */
+  async collect(max) {
+    const result = [];
+    for await (const item of this) {
+      result.push(item);
+      if (max !== void 0 && result.length >= max) break;
+    }
+    return result;
+  }
+  /**
+   * Вычисляет позицию следующей страницы и решает, продолжать ли.
+   *
+   * Здесь же стоят предохранители: пустая страница при `hasMore`, неизменившийся курсор
+   * и отсутствие курсора останавливают перебор. Без них ошибка на сервере превратилась бы
+   * в бесконечный цикл запросов.
+   */
+  #advance(previous, page) {
+    if (!page.hasMore || page.items.length === 0) {
+      this.#finished = true;
+      return previous;
+    }
+    if (this.#options.mode === "cursor") {
+      const cursor = page.nextCursor ?? void 0;
+      if (!cursor || cursor === previous.cursor) {
+        this.#finished = true;
+        return previous;
+      }
+      return { cursor };
+    }
+    if (this.#options.mode === "page") {
+      return { page: (previous.page ?? 1) + 1 };
+    }
+    return { offset: page.nextOffset ?? (previous.offset ?? 0) + page.items.length };
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  /** @internal */
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /** Переносит общие поля опций запроса в параметры транспорта. */
+  requestOptions(options) {
+    if (!options) return {};
+    return {
+      ...options.signal !== void 0 ? { signal: options.signal } : {},
+      ...options.timeout !== void 0 ? { timeout: options.timeout } : {},
+      ...options.headers !== void 0 ? { headers: options.headers } : {},
+      ...options.retry !== void 0 ? { retry: options.retry } : {}
+    };
+  }
+  /**
+   * Собирает перебор страниц.
+   *
+   * @param mode схема пагинации эндпоинта
+   * @param load загружает одну страницу для указанной позиции
+   */
+  paginate(mode, load, options) {
+    return new Paginator({
+      mode,
+      load,
+      ...options?.maxPages !== void 0 ? { maxPages: options.maxPages } : {},
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+};
+function withPageState(query, state) {
+  return {
+    ...query,
+    ...state.cursor !== void 0 ? { cursor: state.cursor } : {},
+    ...state.page !== void 0 ? { page: state.page } : {},
+    ...state.offset !== void 0 ? { offset: state.offset } : {}
+  };
+}
+
+// src/resources/auth.ts
+var AuthResource = class extends BaseResource {
+  #auth;
+  constructor(http, deps) {
+    super(http);
+    this.#auth = deps.auth;
+  }
+  /**
+   * Регистрирует аккаунт и запускает подтверждение по коду.
+   *
+   * @returns `flowToken`, который нужно передать в {@link verifyOtp}
+   */
+  async signUp(credentials, options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/sign-up",
+      body: credentials,
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+    const flowToken = pickString(body, "flowToken");
+    if (!flowToken) {
+      throw new ItdConfigError("\u0421\u0435\u0440\u0432\u0435\u0440 \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B flowToken \u043F\u0440\u0438 \u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u0438");
+    }
+    return flowToken;
+  }
+  /**
+   * Выполняет вход.
+   *
+   * Если сервер потребовал код подтверждения, вернётся `status: 'otp_required'` —
+   * тогда продолжайте через {@link verifyOtp} либо воспользуйтесь {@link signInWithOtp}.
+   *
+   * При успешном входе токен сохраняется в клиенте автоматически.
+   */
+  async signIn(credentials, options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/sign-in",
+      body: credentials,
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+    const accessToken = pickString(body, "accessToken");
+    if (accessToken) {
+      await this.#auth.setAccessToken(accessToken);
+      return { status: "authenticated", accessToken };
+    }
+    return { status: "otp_required", flowToken: pickString(body, "flowToken") };
+  }
+  /**
+   * Подтверждает вход кодом из письма.
+   *
+   * Полученный токен сохраняется в клиенте автоматически.
+   */
+  async verifyOtp(input, options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/verify-otp",
+      body: input,
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+    const accessToken = pickString(body, "accessToken");
+    if (!accessToken) {
+      throw new ItdConfigError("\u0421\u0435\u0440\u0432\u0435\u0440 \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B accessToken \u043F\u043E\u0441\u043B\u0435 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F \u043A\u043E\u0434\u0430");
+    }
+    await this.#auth.setAccessToken(accessToken);
+    return accessToken;
+  }
+  /** Отправляет код подтверждения повторно. */
+  resendOtp(input, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/resend-otp",
+      body: input,
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Полный вход с подтверждением по коду.
+   *
+   * Удобно для скриптов и ботов: код запрашивается функцией `getOtp`, а всё остальное
+   * библиотека делает сама.
+   *
+   * @example
+   * ```ts
+   * import { createInterface } from 'node:readline/promises';
+   *
+   * const rl = createInterface({ input: process.stdin, output: process.stdout });
+   *
+   * const token = await itd.auth.signInWithOtp({
+   *   email, password,
+   *   getOtp: () => rl.question('Код из письма: '),
+   * });
+   * ```
+   */
+  async signInWithOtp(input, options = {}) {
+    const { getOtp, ...credentials } = input;
+    const result = await this.signIn(credentials, options);
+    if (result.status === "authenticated") return result.accessToken;
+    if (!result.flowToken) {
+      throw new ItdConfigError(
+        "\u0421\u0435\u0440\u0432\u0435\u0440 \u0437\u0430\u043F\u0440\u043E\u0441\u0438\u043B \u043A\u043E\u0434 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F, \u043D\u043E \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B flowToken \u2014 \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C \u0432\u0445\u043E\u0434 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E"
+      );
+    }
+    const otp = await getOtp();
+    return this.verifyOtp({ ...credentials, otp, flowToken: result.flowToken }, options);
+  }
+  /**
+   * Обновляет токен доступа.
+   *
+   * Параллельные вызовы объединяются в один сетевой запрос. При включённом `autoRefresh`
+   * вызывать вручную обычно не нужно.
+   */
+  refresh() {
+    return this.#auth.refresh();
+  }
+  /**
+   * Есть ли признак живой сессии обновления.
+   *
+   * Проверяет cookie `is_auth`, которую сервер ставит рядом с refresh-токеном. Позволяет
+   * не дёргать API у неавторизованного пользователя. В браузере всегда `true`:
+   * cookie ведёт сама среда, и прочитать её из JS нельзя.
+   */
+  hasRefreshSession() {
+    return this.#auth.hasRefreshSession();
+  }
+  /** Завершает текущую сессию на сервере и очищает локальную. */
+  async logout(options = {}) {
+    await this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/logout",
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+    await this.#auth.clear();
+  }
+  /** Завершает все сессии пользователя и очищает локальную. */
+  async logoutAll(options = {}) {
+    await this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/logout-all",
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+    await this.#auth.clear();
+  }
+  /** Забывает сессию локально, не обращаясь к серверу. */
+  signOut() {
+    return this.#auth.clear();
+  }
+  /** Запрашивает письмо для сброса пароля. */
+  forgotPassword(email, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/forgot-password",
+      body: { email },
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Устанавливает новый пароль по токену из письма. */
+  resetPassword(input, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/reset-password",
+      body: input,
+      skipAuth: true,
+      skipAuthRefresh: true,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Меняет пароль. Требует действующей сессии обновления. */
+  changePassword(input, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/auth/change-password",
+      body: input,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Возвращает адрес для входа через внешнего провайдера.
+   *
+   * Сам переход выполняет приложение: в браузере — редиректом, в приложении — открытием
+   * системного браузера.
+   *
+   * @example
+   * ```ts
+   * window.location.href = itd.auth.oauthUrl('yandex');
+   * ```
+   */
+  oauthUrl(provider) {
+    return joinUrl(this.http.baseUrl, `/api/v1/auth/login/${provider}`);
+  }
+  /** Загружает список активных сессий. У текущей поле `isCurrent` равно `true`. */
+  async sessions(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/v1/auth/sessions",
+      ...this.requestOptions(options)
+    });
+    return pickArray(body, "sessions");
+  }
+  /** Завершает указанную сессию. */
+  revokeSession(sessionId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/v1/auth/sessions/${encodeURIComponent(sessionId)}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Завершает все сессии, кроме текущей. */
+  revokeOtherSessions(options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: "/api/v1/auth/sessions",
+      ...this.requestOptions(options)
+    });
+  }
+};
+
+// src/resources/comments.ts
+var CommentsResource = class extends BaseResource {
+  #uploadFiles;
+  constructor(http, deps) {
+    super(http);
+    this.#uploadFiles = deps.uploadFiles;
+  }
+  /**
+   * Загружает страницу ответов на комментарий.
+   *
+   * Здесь пагинация **постраничная**, в отличие от комментариев к посту, где курсорная.
+   */
+  async replies(commentId, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}/replies`,
+      query: { limit: params.limit, page: params.page },
+      ...this.requestOptions(params)
+    });
+    return readPagedPage(body, "replies");
+  }
+  /** Перебирает ответы на комментарий. */
+  iterateReplies(commentId, params = {}) {
+    const path = `/api/comments/${encodePathSegment(commentId, "commentId")}/replies`;
+    return this.paginate(
+      "page",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState({ limit: params.limit }, state),
+          ...this.requestOptions(params)
+        });
+        return readPagedPage(body, "replies");
+      },
+      params
+    );
+  }
+  /**
+   * Отвечает на комментарий.
+   *
+   * @example
+   * ```ts
+   * await itd.comments.reply(commentId, 'согласен');
+   * await itd.comments.reply(commentId, (c) => c.content('и вот почему').replyTo(userId));
+   * ```
+   */
+  async reply(commentId, input, options = {}) {
+    const data = resolveComment(typeof input === "string" ? { content: input } : input, true);
+    const existing = data.attachmentIds ?? [];
+    const files = data.files ?? [];
+    const attachmentIds = files.length > 0 ? [...existing, ...await this.#uploadFiles(files, options)] : existing;
+    return this.http.request({
+      method: "POST",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}/replies`,
+      body: {
+        content: data.content ?? "",
+        attachmentIds,
+        ...data.replyToUserId ? { replyToUserId: data.replyToUserId } : {}
+      },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Редактирует текст комментария. */
+  update(commentId, content, options = {}) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
+      body: { content },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Удаляет комментарий. Восстановить его можно через {@link restore}. */
+  remove(commentId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Восстанавливает удалённый комментарий. */
+  restore(commentId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}/restore`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Ставит реакцию на комментарий. */
+  like(commentId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Убирает реакцию с комментария. */
+  unlike(commentId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/comments/${encodePathSegment(commentId, "commentId")}/like`,
+      ...this.requestOptions(options)
+    });
+  }
+};
+
+// src/core/mime.ts
+var IMAGE_MIME_TYPES = Object.freeze([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/heic",
+  "image/heif"
+]);
+var VIDEO_MIME_TYPES = Object.freeze(["video/mp4", "video/webm", "video/quicktime"]);
+var AUDIO_MIME_TYPES = Object.freeze(["audio/ogg"]);
+var ALLOWED_MIME_TYPES = Object.freeze([
+  ...IMAGE_MIME_TYPES,
+  ...VIDEO_MIME_TYPES,
+  ...AUDIO_MIME_TYPES
+]);
+var EXTENSION_TO_MIME = Object.freeze({
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  jfif: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  heic: "image/heic",
+  heif: "image/heif",
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  qt: "video/quicktime",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  opus: "audio/ogg"
+});
+function mimeFromFilename(filename) {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0) return void 0;
+  return EXTENSION_TO_MIME[filename.slice(dot + 1).toLowerCase()];
+}
+function isAllowedMime(mimeType) {
+  return ALLOWED_MIME_TYPES.includes(mimeType.toLowerCase());
+}
+function assertAllowedMime(mimeType, filename) {
+  if (!mimeType) {
+    throw new ItdConfigError(
+      `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u0442\u0438\u043F \u0444\u0430\u0439\u043B\u0430${filename ? ` \xAB${filename}\xBB` : ""}. \u0423\u043A\u0430\u0436\u0438\u0442\u0435 \u0435\u0433\u043E \u044F\u0432\u043D\u043E: { data, filename, contentType }.`
+    );
+  }
+  if (!isAllowedMime(mimeType)) {
+    throw new ItdConfigError(
+      `\u0422\u0438\u043F \xAB${mimeType}\xBB \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0437\u0430\u0433\u0440\u0443\u0437\u043A\u043E\u0439. \u0414\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0435: ${ALLOWED_MIME_TYPES.join(", ")}.`
+    );
+  }
+}
+
+// src/resources/files.ts
+var DEFAULT_UPLOAD_TIMEOUT = 3e5;
+var FilesResource = class extends BaseResource {
+  #readFile;
+  constructor(http, deps = {}) {
+    super(http);
+    this.#readFile = deps.readFile;
+  }
+  /**
+   * Подключает чтение файлов с диска.
+   *
+   * Вызывается точкой входа `itd-api/node`; в основном бандле работы с файловой
+   * системой нет, чтобы браузерные сборщики не пытались разрешить `node:fs`.
+   */
+  setFileReader(readFile) {
+    this.#readFile = readFile;
+  }
+  /**
+   * Загружает файл и возвращает его идентификатор.
+   *
+   * @remarks
+   * Кроме типа сервер проверяет и само изображение: слишком маленькие картинки
+   * он отклоняет сообщением «Не удалось проверить изображение». Точный порог
+   * неизвестен, но 64×64 проходит.
+   *
+   * @example
+   * ```ts
+   * const file = await itd.files.upload(blob, { filename: 'photo.jpg' });
+   * await itd.posts.create({ content: 'смотрите', attachmentIds: [file.id] });
+   * ```
+   */
+  async upload(input, options = {}) {
+    const prepared = await this.prepare(input, options);
+    const form = new FormData();
+    form.set("file", prepared.blob, prepared.filename);
+    return this.http.request({
+      method: "POST",
+      path: "/api/files/upload",
+      body: form,
+      timeout: options.timeout ?? DEFAULT_UPLOAD_TIMEOUT,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Загружает несколько файлов, сохраняя порядок.
+   *
+   * Файлы отправляются последовательно: параллельная загрузка нескольких видео легко
+   * упирается в ограничение частоты, а порядок вложений в посте важен.
+   *
+   * @returns идентификаторы вложений в том же порядке, что и входные файлы
+   */
+  async uploadMany(files, options = {}) {
+    const ids = [];
+    for (const file of files) {
+      const uploaded = await this.upload(file, options);
+      ids.push(uploaded.id);
+    }
+    return ids;
+  }
+  /**
+   * Загружает сведения о файле.
+   *
+   * @remarks
+   * Сервер отвечает `404` даже на только что загруженный файл, который ещё никуда
+   * не прикреплён, — проверено на боевом API. Практической пользы у метода пока нет,
+   * он оставлен для полноты.
+   */
+  get(fileId, options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Удаляет загруженный файл. */
+  remove(fileId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/files/${encodePathSegment(fileId, "fileId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Приводит любой поддерживаемый вход к `Blob` с именем и проверенным типом. */
+  async prepare(input, options) {
+    const { data, filename, contentType } = await this.#normalize(input, options);
+    const type = contentType ?? ((data instanceof Blob ? data.type : void 0) || mimeFromFilename(filename));
+    if (options.validateMime !== false) assertAllowedMime(type || void 0, filename);
+    const blob = data instanceof Blob && (!type || data.type === type) ? data : new Blob([data], { type: type ?? "" });
+    return { blob, filename };
+  }
+  async #normalize(input, options) {
+    if (typeof input === "string") {
+      if (!this.#readFile) {
+        throw new ItdConfigError(
+          `\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u043F\u043E \u043F\u0443\u0442\u0438 \xAB${input}\xBB \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u0430 \u0442\u043E\u043B\u044C\u043A\u043E \u0432 Node, Bun \u0438 Deno. \u041F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0435\u0451 \u0438\u043C\u043F\u043E\u0440\u0442\u043E\u043C 'itd-api/node' \u043B\u0438\u0431\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 Blob \u0438\u043B\u0438 File.`
+        );
+      }
+      const file = await this.#readFile(input);
+      return {
+        data: file.data,
+        filename: options.filename ?? file.filename,
+        ...options.contentType ? { contentType: options.contentType } : {}
+      };
+    }
+    if (input instanceof ArrayBuffer || ArrayBuffer.isView(input) || input instanceof Blob) {
+      const fallbackName = input instanceof File ? input.name : options.filename ?? this.#nameFromMime(options.contentType);
+      return {
+        data: input,
+        filename: options.filename ?? fallbackName,
+        ...options.contentType ? { contentType: options.contentType } : {}
+      };
+    }
+    const contentType = input.contentType ?? options.contentType;
+    return {
+      data: input.data,
+      filename: input.filename ?? options.filename ?? this.#nameFromMime(contentType),
+      ...contentType ? { contentType } : {}
+    };
+  }
+  /** Подбирает имя файла, когда его не передали: сервер ждёт непустое поле. */
+  #nameFromMime(contentType) {
+    const extension = contentType?.split("/")[1]?.split(";")[0];
+    return extension ? `file.${extension}` : "file";
+  }
+};
+
+// src/resources/misc.ts
+var HashtagsResource = class extends BaseResource {
+  /**
+   * Ищет хэштеги.
+   *
+   * Без строки запроса возвращает общий список.
+   */
+  async search(query, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/hashtags",
+      query: { q: query, limit: params.limit },
+      ...this.requestOptions(params)
+    });
+    return pickArray(body, "hashtags");
+  }
+  /** Загружает трендовые хэштеги. */
+  async trending(params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/hashtags/trending",
+      query: { limit: params.limit },
+      ...this.requestOptions(params)
+    });
+    return pickArray(body, "hashtags");
+  }
+  /**
+   * Загружает страницу постов по хэштегу.
+   *
+   * @param tag название без решётки; кодируется автоматически, поэтому кириллица
+   * и пробелы допустимы
+   */
+  async posts(tag, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: `/api/hashtags/${encodePathSegment(tag, "tag")}/posts`,
+      query: { limit: params.limit, cursor: params.cursor },
+      ...this.requestOptions(params)
+    });
+    return readCursorPage(body, "posts");
+  }
+  /** Перебирает посты по хэштегу. */
+  iteratePosts(tag, params = {}) {
+    const path = `/api/hashtags/${encodePathSegment(tag, "tag")}/posts`;
+    return this.paginate(
+      "cursor",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState({ limit: params.limit }, state),
+          ...this.requestOptions(params)
+        });
+        return readCursorPage(body, "posts");
+      },
+      params
+    );
+  }
+};
+var SearchResource = class extends BaseResource {
+  /**
+   * Ищет пользователей и хэштеги одним запросом.
+   *
+   * @example
+   * ```ts
+   * const { users, hashtags } = await itd.search.all('арт');
+   * ```
+   */
+  async all(query, options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/search",
+      query: { q: query },
+      ...this.requestOptions(options)
+    });
+    return {
+      users: pickArray(body, "users"),
+      hashtags: pickArray(body, "hashtags")
+    };
+  }
+};
+var ReportsResource = class extends BaseResource {
+  /**
+   * Отправляет жалобу.
+   *
+   * Повторная жалоба на тот же объект отклоняется сервером с сообщением
+   * «Вы уже отправляли жалобу на этот контент».
+   *
+   * @example
+   * ```ts
+   * await itd.reports.create(report.post(postId).reason('spam'));
+   * await itd.reports.create({ targetType: 'user', targetId, reason: 'fraud' });
+   * ```
+   */
+  create(input, options = {}) {
+    const data = resolveReport(input);
+    return this.http.request({
+      method: "POST",
+      path: "/api/reports",
+      body: data,
+      ...this.requestOptions(options)
+    });
+  }
+};
+var VerificationResource = class extends BaseResource {
+  /** Загружает статус заявки. Значение `none` означает, что заявка не подавалась. */
+  status(options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: "/api/verification/status",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Подаёт заявку на верификацию с видео. */
+  submit(videoUrl, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/verification/submit",
+      body: { videoUrl },
+      ...this.requestOptions(options)
+    });
+  }
+};
+var SubscriptionResource = class extends BaseResource {
+  /** Загружает состояние подписки и её цену. */
+  status(options = {}) {
+    return this.http.request({
+      method: "GET",
+      // Завершающий слэш обязателен.
+      path: "/api/v1/subscription/",
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Запускает оплату подписки.
+   *
+   * Форма ответа в документации API не описана, поэтому тип результата не уточняется.
+   */
+  pay(options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/subscription/pay",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Включает или отключает автопродление. */
+  setAutoRenewal(enabled, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/subscription/auto-renewal",
+      body: { enabled },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Запускает привязку карты. */
+  bindCard(options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/subscription/bind-card",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Загружает список способов оплаты. Пустой массив, если карт нет. */
+  async methods(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/v1/subscription/methods",
+      ...this.requestOptions(options)
+    });
+    return Array.isArray(body) ? body : [];
+  }
+  /** Делает способ оплаты основным. */
+  setDefaultMethod(methodId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/subscription/methods/${encodePathSegment(methodId, "methodId")}/default`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Удаляет способ оплаты. */
+  removeMethod(methodId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/v1/subscription/methods/${encodePathSegment(methodId, "methodId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+};
+var PlatformResource = class extends BaseResource {
+  /** Загружает журнал изменений. */
+  async changelog(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/platform/changelog",
+      ...this.requestOptions(options)
+    });
+    return Array.isArray(body) ? body : [];
+  }
+  /** Загружает анонсы платформы. */
+  async announcements(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/platform/announcements",
+      ...this.requestOptions(options)
+    });
+    return pickArray(body, "announcements");
+  }
+  /** Загружает баннер текущего события — виджет «портал». */
+  portal(options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: "/api/v1/portal",
+      ...this.requestOptions(options)
+    });
+  }
+};
+var TelemetryResource = class extends BaseResource {
+  /**
+   * Отправляет время просмотра постов.
+   *
+   * @experimental Имена полей на проводе сжаты (`ai`, `v`, `s`), и их соответствие
+   * смыслу **не проверено** на реальных запросах. Может измениться без предупреждения.
+   */
+  dwell(entries, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/i",
+      body: {
+        items: entries.map((entry) => ({
+          ai: entry.postId,
+          v: entry.duration,
+          ...entry.vs ? { s: entry.vs } : {}
+        }))
+      },
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Отправляет события взаимодействия с контентом.
+   *
+   * @experimental См. предупреждение у {@link TelemetryResource}.
+   */
+  interaction(entries, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/x",
+      body: {
+        items: entries.map((entry) => ({
+          t: entry.type,
+          ...entry.value !== void 0 ? { v: entry.value } : {},
+          ...entry.postId ? { ai: entry.postId } : {},
+          ...entry.attachmentId ? { mi: entry.attachmentId } : {},
+          ...entry.vs ? { s: entry.vs } : {}
+        }))
+      },
+      ...this.requestOptions(options)
+    });
+  }
+};
+
+// src/resources/notifications.ts
+var READ_BATCH_SIZE = 20;
+function readSettings(body) {
+  return {
+    enabled: pickBoolean(body, "enabled", true),
+    sound: pickBoolean(body, "sound", true),
+    follows: pickBoolean(body, "follows", true),
+    wallPosts: pickBoolean(body, "wallPosts", true),
+    likes: pickBoolean(body, "likes", true),
+    comments: pickBoolean(body, "comments", true),
+    mentions: pickBoolean(body, "mentions", true)
+  };
+}
+var NotificationsResource = class extends BaseResource {
+  /**
+   * Загружает страницу уведомлений.
+   *
+   * Пагинация здесь основана на смещении. Сайт итд.com оборачивает смещение в строку
+   * и притворяется, что это курсор; библиотека отдаёт честное число.
+   *
+   * @example
+   * ```ts
+   * const page = await itd.notifications.list({ limit: 20 });
+   * const next = await itd.notifications.list({ limit: 20, offset: page.nextOffset });
+   * ```
+   */
+  async list(params = {}) {
+    const offset = params.offset ?? 0;
+    const body = await this.http.request({
+      method: "GET",
+      // Завершающий слэш обязателен: без него сервер отвечает ошибкой.
+      path: "/api/notifications/",
+      query: { limit: params.limit, offset },
+      ...this.requestOptions(params)
+    });
+    const page = readOffsetPage(body, "notifications", offset);
+    return { ...page, items: page.items.map(normalizeNotification) };
+  }
+  /**
+   * Перебирает уведомления.
+   *
+   * @example
+   * ```ts
+   * for await (const notification of itd.notifications.iterate()) {
+   *   console.log(formatNotificationText(notification));
+   * }
+   * ```
+   */
+  iterate(params = {}) {
+    return this.paginate(
+      "offset",
+      async (state) => {
+        const offset = state.offset ?? params.offset ?? 0;
+        const body = await this.http.request({
+          method: "GET",
+          path: "/api/notifications/",
+          query: { limit: params.limit, offset },
+          ...this.requestOptions(params)
+        });
+        const page = readOffsetPage(body, "notifications", offset);
+        return { ...page, items: page.items.map(normalizeNotification) };
+      },
+      params
+    );
+  }
+  /** Загружает число непрочитанных уведомлений. */
+  async count(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/notifications/count",
+      ...this.requestOptions(options)
+    });
+    return pickNumber(body, "count", 0);
+  }
+  /**
+   * Отмечает уведомление прочитанным.
+   *
+   * @returns сколько записей отметил сервер
+   */
+  async markRead(notificationId, options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: `/api/notifications/${encodePathSegment(notificationId, "notificationId")}/read`,
+      ...this.requestOptions(options)
+    });
+    return pickNumber(body, "markedCount", 0);
+  }
+  /**
+   * Отмечает прочитанными сразу несколько уведомлений.
+   *
+   * Список автоматически режется на части по 20 идентификаторов — столько же отправляет
+   * сайт итд.com, поэтому на сервере вероятен предел. Части уходят последовательно,
+   * результат суммируется.
+   *
+   * @returns сколько записей отметил сервер суммарно
+   */
+  async markReadBatch(ids, options = {}) {
+    let marked = 0;
+    for (let index = 0; index < ids.length; index += READ_BATCH_SIZE) {
+      const chunk = ids.slice(index, index + READ_BATCH_SIZE);
+      const body = await this.http.request({
+        method: "POST",
+        path: "/api/notifications/read-batch",
+        body: { ids: chunk },
+        ...this.requestOptions(options)
+      });
+      marked += pickNumber(body, "markedCount", 0);
+    }
+    return marked;
+  }
+  /** Отмечает прочитанными все уведомления. */
+  async markAllRead(options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: "/api/notifications/read-all",
+      ...this.requestOptions(options)
+    });
+    return pickNumber(body, "markedCount", 0);
+  }
+  /** Загружает настройки уведомлений. */
+  async getSettings(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/notifications/settings",
+      ...this.requestOptions(options)
+    });
+    return readSettings(body);
+  }
+  /**
+   * Обновляет настройки уведомлений.
+   *
+   * Отправляются только изменяемые поля, в том же виде, в каком сервер их возвращает.
+   */
+  async updateSettings(input, options = {}) {
+    const payload = {};
+    for (const key of [
+      "enabled",
+      "sound",
+      "follows",
+      "wallPosts",
+      "likes",
+      "comments",
+      "mentions"
+    ]) {
+      const value = input[key];
+      if (value !== void 0) payload[key] = value;
+    }
+    const body = await this.http.request({
+      method: "PUT",
+      path: "/api/notifications/settings",
+      body: payload,
+      ...this.requestOptions(options)
+    });
+    return readSettings(body);
+  }
+};
+
+// src/resources/posts.ts
+var PostsResource = class extends BaseResource {
+  #uploadFiles;
+  constructor(http, deps) {
+    super(http);
+    this.#uploadFiles = deps.uploadFiles;
+  }
+  /**
+   * Загружает страницу ленты.
+   *
+   * @example
+   * ```ts
+   * const page = await itd.posts.list({ tab: FeedTab.Following, limit: 20 });
+   * const next = await itd.posts.list({ tab: FeedTab.Following, cursor: page.nextCursor ?? undefined });
+   * ```
+   */
+  async list(params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/posts",
+      query: { tab: params.tab, limit: params.limit, cursor: params.cursor },
+      ...this.requestOptions(params)
+    });
+    return readCursorPage(body, "posts");
+  }
+  /**
+   * Перебирает ленту, сама подставляя курсоры.
+   *
+   * @example
+   * ```ts
+   * for await (const post of itd.posts.iterate({ tab: 'following' })) {
+   *   console.log(post.author.username, post.content);
+   * }
+   * ```
+   */
+  iterate(params = {}) {
+    return this.paginate(
+      "cursor",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path: "/api/posts",
+          query: withPageState({ tab: params.tab, limit: params.limit }, state),
+          ...this.requestOptions(params)
+        });
+        return readCursorPage(body, "posts");
+      },
+      params
+    );
+  }
+  /**
+   * Публикует пост.
+   *
+   * Принимает обычный объект, {@link PostBuilder} или функцию-настройщик. Файлы из поля
+   * `files` загружаются автоматически, порядок вложений сохраняется.
+   *
+   * @example
+   * ```ts
+   * await itd.posts.create({ content: 'привет' });
+   * await itd.posts.create((p) => p.content('привет').attach('./photo.jpg'));
+   * ```
+   */
+  async create(input, options = {}) {
+    const data = resolvePost(input);
+    const attachmentIds = await this.#collectAttachments(data, options);
+    return this.http.request({
+      method: "POST",
+      path: "/api/posts",
+      body: {
+        content: data.content ?? "",
+        ...data.spans ? { spans: data.spans } : {},
+        ...data.wallRecipientId ? { wallRecipientId: data.wallRecipientId } : {},
+        ...attachmentIds.length > 0 ? { attachmentIds } : {},
+        ...data.poll ? { poll: data.poll } : {}
+      },
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Загружает один пост вместе с топовыми комментариями.
+   *
+   * В отличие от списков, здесь у поста заполнено поле `comments`.
+   */
+  get(postId, options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Редактирует текст поста. */
+  update(postId, input, options = {}) {
+    return this.http.request({
+      method: "PUT",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+      body: { content: input.content ?? "", ...input.spans ? { spans: input.spans } : {} },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Удаляет пост. Восстановить его можно через {@link restore}. */
+  remove(postId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Восстанавливает удалённый пост. */
+  restore(postId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/restore`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Ставит реакцию на пост. */
+  like(postId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Убирает реакцию с поста. */
+  unlike(postId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/like`,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Делает репост с необязательным комментарием.
+   *
+   * Вложения к репосту не поддерживаются: сервер их игнорирует, поэтому параметров
+   * для файлов здесь нет.
+   */
+  repost(postId, content = "", options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
+      body: { content },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Отменяет репост. */
+  unrepost(postId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/repost`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Закрепляет пост в профиле. */
+  pin(postId, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Открепляет пост. */
+  unpin(postId, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/pin`,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Голосует в опросе.
+   *
+   * @param optionIds выбранные варианты; несколько допустимы только при `multipleChoice`
+   */
+  vote(postId, optionIds, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/poll/vote`,
+      body: { optionIds },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Запрашивает счётчики сразу для нескольких постов. */
+  async stats(ids, options = {}) {
+    const body = await this.http.request({
+      method: "POST",
+      path: "/api/posts/stats",
+      body: { ids },
+      ...this.requestOptions(options)
+    });
+    return pickArray(body, "posts");
+  }
+  /** Загружает страницу постов пользователя (его стену). */
+  async byUser(user, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: `/api/posts/user/${encodePathSegment(user, "user")}`,
+      query: {
+        limit: params.limit,
+        cursor: params.cursor,
+        sort: params.sort,
+        pinnedPostId: params.pinnedPostId
+      },
+      ...this.requestOptions(params)
+    });
+    return readCursorPage(body, "posts");
+  }
+  /** Перебирает посты пользователя. */
+  iterateByUser(user, params = {}) {
+    const path = `/api/posts/user/${encodePathSegment(user, "user")}`;
+    return this.paginate(
+      "cursor",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState(
+            { limit: params.limit, sort: params.sort, pinnedPostId: params.pinnedPostId },
+            state
+          ),
+          ...this.requestOptions(params)
+        });
+        return readCursorPage(body, "posts");
+      },
+      params
+    );
+  }
+  /** Загружает страницу постов, которые пользователь отметил реакцией. */
+  async likedByUser(user, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: `/api/posts/user/${encodePathSegment(user, "user")}/liked`,
+      query: { limit: params.limit, cursor: params.cursor },
+      ...this.requestOptions(params)
+    });
+    return readCursorPage(body, "posts");
+  }
+  /** Перебирает посты, которые пользователь отметил реакцией. */
+  iterateLikedByUser(user, params = {}) {
+    const path = `/api/posts/user/${encodePathSegment(user, "user")}/liked`;
+    return this.paginate(
+      "cursor",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState({ limit: params.limit }, state),
+          ...this.requestOptions(params)
+        });
+        return readCursorPage(body, "posts");
+      },
+      params
+    );
+  }
+  /**
+   * Загружает страницу комментариев к посту.
+   *
+   * У этого эндпоинта курсор и признак продолжения лежат рядом со списком, а не внутри
+   * объекта `pagination`, как у остальных, — разница скрыта внутри.
+   */
+  async comments(postId, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/comments`,
+      query: { limit: params.limit, cursor: params.cursor, sort: params.sort },
+      ...this.requestOptions(params)
+    });
+    return readFlatCursorPage(body, "comments");
+  }
+  /** Перебирает комментарии к посту. */
+  iterateComments(postId, params = {}) {
+    const path = `/api/posts/${encodePathSegment(postId, "postId")}/comments`;
+    return this.paginate(
+      "cursor",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState({ limit: params.limit, sort: params.sort }, state),
+          ...this.requestOptions(params)
+        });
+        return readFlatCursorPage(body, "comments");
+      },
+      params
+    );
+  }
+  /**
+   * Комментирует пост.
+   *
+   * @example
+   * ```ts
+   * await itd.posts.comment(postId, 'согласен');
+   * await itd.posts.comment(postId, (c) => c.content('смотри').attach('./meme.png'));
+   * ```
+   */
+  async comment(postId, input, options = {}) {
+    const data = resolveComment(typeof input === "string" ? { content: input } : input);
+    const attachmentIds = await this.#collectAttachments(data, options);
+    return this.http.request({
+      method: "POST",
+      path: `/api/posts/${encodePathSegment(postId, "postId")}/comments`,
+      body: { content: data.content ?? "", attachmentIds },
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Отправляет голосовой комментарий.
+   *
+   * Текста у такого комментария нет: сервер ждёт пустой `content` и одно аудиовложение
+   * в формате `audio/ogg`.
+   *
+   * @example
+   * ```ts
+   * await itd.posts.voiceComment(postId, './answer.ogg');
+   * ```
+   */
+  voiceComment(postId, audio, options = {}) {
+    return this.comment(postId, { content: "", files: [audio] }, options);
+  }
+  /** Загружает файлы из входных данных и объединяет их с уже готовыми идентификаторами. */
+  async #collectAttachments(data, options) {
+    const existing = data.attachmentIds ?? [];
+    const files = data.files ?? [];
+    if (files.length === 0) return existing;
+    const uploaded = await this.#uploadFiles(files, options);
+    return [...existing, ...uploaded];
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class extends BaseResource {
+  /** Загружает свой профиль — с подпиской и признаком подтверждённого телефона. */
+  me(options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: "/api/users/me",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Обновляет свой профиль. Передавайте только изменяемые поля. */
+  updateMe(input, options = {}) {
+    return this.http.request({
+      method: "PUT",
+      path: "/api/users/me",
+      body: input,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Деактивирует аккаунт. Вернуть его можно через {@link restore}. */
+  deactivate(options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: "/api/users/me",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Восстанавливает деактивированный аккаунт. */
+  restore(options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/users/me/restore",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Создаёт профиль после регистрации. */
+  createProfile(input, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/users/profile",
+      body: input,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Загружает профиль пользователя.
+   *
+   * @param user UUID **или** имя пользователя — подходит и то, и другое
+   *
+   * @example
+   * ```ts
+   * const profile = await itd.users.get('durov');
+   * await itd.posts.create({ content: 'привет', wallRecipientId: profile.id });
+   * ```
+   */
+  get(user, options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: `/api/users/${encodePathSegment(user, "user")}`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Проверяет, свободно ли имя пользователя. */
+  async checkUsername(username, options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/users/check-username",
+      query: { username },
+      ...this.requestOptions(options)
+    });
+    return pickBoolean(body, "available");
+  }
+  /** Ищет пользователей по строке запроса. */
+  async search(query, params = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/users/search",
+      query: { q: query, limit: params.limit },
+      ...this.requestOptions(params)
+    });
+    return pickArray(body, "users");
+  }
+  /** Загружает рекомендации, на кого подписаться. */
+  async whoToFollow(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/users/suggestions/who-to-follow",
+      ...this.requestOptions(options)
+    });
+    return pickArray(body, "users");
+  }
+  /** Загружает рейтинг кланов. */
+  async topClans(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/users/stats/top-clans",
+      ...this.requestOptions(options)
+    });
+    return pickArray(body, "clans");
+  }
+  /**
+   * Подписывается на пользователя.
+   *
+   * У закрытого профиля вместо подписки отправляется заявка — это видно по полю `status`.
+   */
+  follow(user, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/users/${encodePathSegment(user, "user")}/follow`,
+      body: {},
+      ...this.requestOptions(options)
+    });
+  }
+  /** Отписывается от пользователя. */
+  unfollow(user, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/users/${encodePathSegment(user, "user")}/follow`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Загружает страницу подписчиков. */
+  followers(user, params = {}) {
+    return this.#userPage(`/api/users/${encodePathSegment(user, "user")}/followers`, params);
+  }
+  /** Перебирает подписчиков. */
+  iterateFollowers(user, params = {}) {
+    return this.#userPaginator(`/api/users/${encodePathSegment(user, "user")}/followers`, params);
+  }
+  /** Загружает страницу подписок. */
+  following(user, params = {}) {
+    return this.#userPage(`/api/users/${encodePathSegment(user, "user")}/following`, params);
+  }
+  /** Перебирает подписки. */
+  iterateFollowing(user, params = {}) {
+    return this.#userPaginator(`/api/users/${encodePathSegment(user, "user")}/following`, params);
+  }
+  /**
+   * Проверяет, подписаны ли вы, сразу для нескольких пользователей.
+   *
+   * @returns объект «идентификатор пользователя → подписаны ли вы»
+   *
+   * @example
+   * ```ts
+   * const statuses = await itd.users.followStatus([userA, userB]);
+   * // { 'b89dee4f-…': true, '35ea3059-…': false }
+   * ```
+   */
+  followStatus(userIds, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/users/follow-status",
+      body: { userIds },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Блокирует пользователя. */
+  block(user, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/users/${encodePathSegment(user, "user")}/block`,
+      body: {},
+      ...this.requestOptions(options)
+    });
+  }
+  /** Снимает блокировку. */
+  unblock(user, options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/api/users/${encodePathSegment(user, "user")}/block`,
+      ...this.requestOptions(options)
+    });
+  }
+  /** Загружает страницу заблокированных пользователей. */
+  blocked(params = {}) {
+    return this.#userPage("/api/users/me/blocked", params);
+  }
+  /** Перебирает заблокированных пользователей. */
+  iterateBlocked(params = {}) {
+    return this.#userPaginator("/api/users/me/blocked", params);
+  }
+  /** Загружает настройки приватности. */
+  getPrivacy(options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: "/api/users/me/privacy",
+      ...this.requestOptions(options)
+    });
+  }
+  /** Обновляет настройки приватности. Передавайте только изменяемые поля. */
+  updatePrivacy(input, options = {}) {
+    return this.http.request({
+      method: "PUT",
+      path: "/api/users/me/privacy",
+      body: input,
+      ...this.requestOptions(options)
+    });
+  }
+  /**
+   * Загружает значки профиля и выбранный из них.
+   *
+   * `activePin` — строка-идентификатор, а не объект.
+   */
+  async pins(options = {}) {
+    const body = await this.http.request({
+      method: "GET",
+      path: "/api/users/me/pins",
+      ...this.requestOptions(options)
+    });
+    return {
+      pins: pickArray(body, "pins"),
+      // Сервер отдаёт здесь строку-идентификатор, а не объект значка.
+      activePin: pickString(body, "activePin") ?? null
+    };
+  }
+  /** Выбирает активный значок профиля. */
+  setPin(slug, options = {}) {
+    return this.http.request({
+      method: "PUT",
+      path: "/api/users/me/pin",
+      body: { slug },
+      ...this.requestOptions(options)
+    });
+  }
+  /** Снимает активный значок. */
+  removePin(options = {}) {
+    return this.http.request({
+      method: "DELETE",
+      path: "/api/users/me/pin",
+      ...this.requestOptions(options)
+    });
+  }
+  async #userPage(path, params) {
+    const body = await this.http.request({
+      method: "GET",
+      path,
+      query: { limit: params.limit, page: params.page },
+      ...this.requestOptions(params)
+    });
+    return readPagedPage(body, "users");
+  }
+  #userPaginator(path, params) {
+    return this.paginate(
+      "page",
+      async (state) => {
+        const body = await this.http.request({
+          method: "GET",
+          path,
+          query: withPageState({ limit: params.limit }, state),
+          ...this.requestOptions(params)
+        });
+        return readPagedPage(body, "users");
+      },
+      params
+    );
+  }
+};
+
+// src/client.ts
+var ItdClient = class {
+  #config;
+  #http;
+  #authManager;
+  #jar;
+  #queue;
+  /** Авторизация, сессии и пароли. */
+  auth;
+  /** Профили, подписки, блокировки, приватность. */
+  users;
+  /** Лента, публикация, реакции, репосты, комментарии к постам. */
+  posts;
+  /** Ответы на комментарии и действия над ними. */
+  comments;
+  /** Загрузка файлов и медиа. */
+  files;
+  /** Уведомления: список, счётчик, отметки о прочтении, настройки. */
+  notifications;
+  /** Хэштеги и посты по ним. */
+  hashtags;
+  /** Глобальный поиск по пользователям и хэштегам. */
+  search;
+  /** Жалобы на контент и пользователей. */
+  reports;
+  /** Верификация профиля. */
+  verification;
+  /** Подписка и способы оплаты. */
+  subscription;
+  /** Сведения о платформе: изменения, анонсы, баннер события. */
+  platform;
+  /**
+   * Телеметрия просмотров.
+   *
+   * @experimental Недокументированные эндпоинты. Библиотека никогда не отправляет их сама.
+   */
+  telemetry;
+  constructor(options = {}) {
+    this.#config = resolveConfig(options);
+    this.#jar = new CookieJar();
+    this.#http = new HttpClient(this.#config);
+    this.#authManager = new AuthManager(this.#config, this.#http, this.#jar);
+    this.#queue = this.#config.rateLimit ? new RequestQueue(this.#config.rateLimit) : void 0;
+    this.#http.setCollaborators({
+      getAuthHeaders: () => this.#authManager.getAuthHeaders(),
+      onUnauthorized: () => this.#authManager.onUnauthorized(),
+      getCookieHeader: (url) => this.#jar.getHeader(url),
+      saveCookies: (url, response) => this.#jar.setFromResponse(url, response),
+      ...this.#queue ? { schedule: this.#queue.schedule.bind(this.#queue) } : {},
+      // Планировщик нужен, даже когда обычные повторы выключены: лимит частоты
+      // живёт по своим правилам и настраивается отдельно, в `rateLimit`.
+      ...this.#config.retry || this.#config.rateLimit ? { nextRetryDelay: this.#createRetryScheduler() } : {},
+      ...this.#queue && this.#config.rateLimit?.respectHeaders ? { onRateLimit: this.#throttleByHeaders.bind(this) } : {}
+    });
+    this.files = new FilesResource(this.#http);
+    const uploadFiles = (files, requestOptions) => this.files.uploadMany(files, requestOptions ?? {});
+    this.auth = new AuthResource(this.#http, { auth: this.#authManager });
+    this.users = new UsersResource(this.#http);
+    this.posts = new PostsResource(this.#http, { uploadFiles });
+    this.comments = new CommentsResource(this.#http, { uploadFiles });
+    this.notifications = new NotificationsResource(this.#http);
+    this.hashtags = new HashtagsResource(this.#http);
+    this.search = new SearchResource(this.#http);
+    this.reports = new ReportsResource(this.#http);
+    this.verification = new VerificationResource(this.#http);
+    this.subscription = new SubscriptionResource(this.#http);
+    this.platform = new PlatformResource(this.#http);
+    this.telemetry = new TelemetryResource(this.#http);
+  }
+  /** Базовый URL, к которому обращается клиент. */
+  get baseUrl() {
+    return this.#config.baseUrl;
+  }
+  /**
+   * Выполняет произвольный запрос к API.
+   *
+   * Запасной путь для случаев, когда нужного метода ещё нет или ответ сервера разошёлся
+   * с документацией. Проходит через ту же авторизацию, очередь и обработку ошибок.
+   *
+   * @example
+   * ```ts
+   * const raw = await itd.request({ method: 'GET', path: '/api/posts', raw: true });
+   * ```
+   */
+  request(options) {
+    return this.#http.request(options);
+  }
+  /**
+   * Подписывается на события авторизации.
+   *
+   * Полезно, чтобы сохранять сессию во внешнее хранилище или узнавать, что вход
+   * окончательно потерян.
+   *
+   * @returns функция отписки
+   *
+   * @example
+   * ```ts
+   * itd.on('tokens', ({ accessToken }) => cache.set('itd', accessToken));
+   * itd.on('authError', () => notifyUser('Сессия истекла, войдите заново'));
+   * ```
+   */
+  on(event, listener) {
+    return this.#authManager.on(event, listener);
+  }
+  /**
+   * Создаёт поток уведомлений в реальном времени.
+   *
+   * Каждый вызов даёт новый независимый поток; обычно он нужен один на приложение.
+   * Соединение поднимается методом `connect()` и держится само.
+   *
+   * @example
+   * ```ts
+   * const stream = itd.realtime();
+   *
+   * stream.on('notification', ({ notification }) => {
+   *   console.log(formatNotificationText(notification));
+   * });
+   * stream.on('unreadCount', (count) => setBadge(count));
+   *
+   * await stream.connect();
+   * ```
+   */
+  realtime(options = {}) {
+    return new ItdRealtime(
+      {
+        baseUrl: this.#config.baseUrl,
+        fetch: this.#config.fetch,
+        getToken: () => this.#authManager.getAccessToken(),
+        refresh: () => this.#authManager.onUnauthorized(),
+        fetchUnreadCount: () => this.notifications.count(),
+        logger: this.#config.logger
+      },
+      options
+    );
+  }
+  /** Текущая сессия целиком — чтобы сохранить её самостоятельно. */
+  getSession() {
+    return this.#authManager.getSession();
+  }
+  /** Восстанавливает сохранённую сессию, включая cookie. */
+  setSession(session) {
+    return this.#authManager.setSession(session);
+  }
+  /**
+   * Подключает чтение файлов с диска.
+   *
+   * Вызывается из `itd-api/node`; напрямую обычно не нужно.
+   *
+   * @internal
+   */
+  setFileReader(readFile) {
+    this.files.setFileReader(readFile);
+  }
+  /**
+   * Придерживает очередь, когда лимит сервера исчерпан.
+   *
+   * Сервер сообщает остаток в заголовке `x-ratelimit-remaining`. Как только тот доходит
+   * до нуля, очередь встаёт на первую паузу лестницы — короткую, потому что окно могло
+   * почти истечь. Если оно ещё действует, следующий запрос получит `429`, и дальше
+   * лестницу отработает планировщик повторов.
+   *
+   * Смысл этой паузы прежде всего в том, чтобы при работе в несколько потоков остальные
+   * запросы не улетели в стену все разом.
+   */
+  #throttleByHeaders(limit, remaining) {
+    if (remaining === void 0 || remaining > 0) return;
+    const first = this.#config.rateLimit?.retryDelays[0];
+    if (first === void 0) return;
+    this.#queue?.pause(first);
+    this.#config.logger?.debug(
+      `\u043B\u0438\u043C\u0438\u0442 \u0441\u0435\u0440\u0432\u0435\u0440\u0430 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D (${remaining} \u0438\u0437 ${limit ?? "?"}), \u043E\u0447\u0435\u0440\u0435\u0434\u044C \u0436\u0434\u0451\u0442 ${first} \u043C\u0441`
+    );
+  }
+  /**
+   * Собирает планировщик повторов и связывает его с очередью.
+   *
+   * Ответ `429` обрабатывается отдельно от прочих ошибок. Причина в том, что сервер
+   * не присылает `Retry-After` и не сообщает время сброса окна: экспоненциальный откат
+   * в сотни миллисекунд здесь бесполезен, а окно измеряется десятками секунд. Вместо
+   * расчёта берётся лестница пауз `rateLimit.retryDelays`, и она не зависит
+   * от `retry.attempts`, у которого совсем другая задача.
+   *
+   * Пауза накладывается на всю очередь: иначе остальные запросы продолжат добивать API,
+   * пока первый ждёт.
+   */
+  #createRetryScheduler() {
+    const retry = this.#config.retry;
+    const scheduler = retry ? createRetryScheduler(retry) : void 0;
+    const queue = this.#queue;
+    const delays = this.#config.rateLimit?.retryDelays ?? [];
+    return (error, attempt, method) => {
+      if (isItdRateLimitError(error)) {
+        const wait = error.retryAfter ?? delays[attempt - 1];
+        if (wait === void 0) return void 0;
+        queue?.pause(wait);
+        this.#config.logger?.debug(`\u043B\u0438\u043C\u0438\u0442 \u0447\u0430\u0441\u0442\u043E\u0442\u044B, \u043F\u043E\u043F\u044B\u0442\u043A\u0430 ${attempt + 1} \u0447\u0435\u0440\u0435\u0437 ${wait} \u043C\u0441`);
+        return wait;
+      }
+      return scheduler?.(error, attempt, method);
+    };
+  }
+};
+function createClient(options = {}) {
+  return new ItdClient(options);
+}
+
+// src/notifications/text.ts
+var UNKNOWN_ACTOR = "\u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C";
+var FALLBACK_TEXT = "\u041D\u043E\u0432\u043E\u0435 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0435";
+var TEMPLATES = Object.freeze({
+  [NotificationType.Follow]: {
+    one: (name) => `${name} \u043F\u043E\u0434\u043F\u0438\u0441\u0430\u043B\u0441\u044F(-\u0430\u0441\u044C) \u043D\u0430 \u0432\u0430\u0441`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043F\u043E\u0434\u043F\u0438\u0441\u0430\u043B\u0438\u0441\u044C \u043D\u0430 \u0432\u0430\u0441`
+  },
+  [NotificationType.FollowRequest]: {
+    one: (name) => `${name} \u0445\u043E\u0447\u0435\u0442 \u043F\u043E\u0434\u043F\u0438\u0441\u0430\u0442\u044C\u0441\u044F \u043D\u0430 \u0432\u0430\u0441`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u0445\u043E\u0442\u044F\u0442 \u043F\u043E\u0434\u043F\u0438\u0441\u0430\u0442\u044C\u0441\u044F \u043D\u0430 \u0432\u0430\u0441`
+  },
+  [NotificationType.FollowAccepted]: {
+    one: (name) => `${name} \u043F\u0440\u0438\u043D\u044F\u043B(\u0430) \u0432\u0430\u0448\u0443 \u0437\u0430\u044F\u0432\u043A\u0443`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043F\u0440\u0438\u043D\u044F\u043B\u0438 \u0432\u0430\u0448\u0443 \u0437\u0430\u044F\u0432\u043A\u0443`
+  },
+  [NotificationType.PostReaction]: {
+    one: (name) => `${name} \u043E\u0446\u0435\u043D\u0438\u043B(\u0430) \u0432\u0430\u0448 \u043F\u043E\u0441\u0442`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043E\u0446\u0435\u043D\u0438\u043B\u0438 \u0432\u0430\u0448 \u043F\u043E\u0441\u0442`
+  },
+  [NotificationType.PostComment]: {
+    one: (name) => `${name} \u043F\u0440\u043E\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0438\u0440\u043E\u0432\u0430\u043B(\u0430) \u0432\u0430\u0448 \u043F\u043E\u0441\u0442`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043F\u0440\u043E\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0438\u0440\u043E\u0432\u0430\u043B\u0438 \u0432\u0430\u0448 \u043F\u043E\u0441\u0442`
+  },
+  [NotificationType.PostRepost]: {
+    one: (name) => `${name} \u0441\u0434\u0435\u043B\u0430\u043B(\u0430) \u0440\u0435\u043F\u043E\u0441\u0442`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u0441\u0434\u0435\u043B\u0430\u043B\u0438 \u0440\u0435\u043F\u043E\u0441\u0442`
+  },
+  [NotificationType.CommentReaction]: {
+    one: (name) => `${name} \u043E\u0446\u0435\u043D\u0438\u043B(\u0430) \u0432\u0430\u0448 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043E\u0446\u0435\u043D\u0438\u043B\u0438 \u0432\u0430\u0448 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439`
+  },
+  [NotificationType.CommentReply]: {
+    one: (name) => `${name} \u043E\u0442\u0432\u0435\u0442\u0438\u043B(\u0430) \u043D\u0430 \u0432\u0430\u0448 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043E\u0442\u0432\u0435\u0442\u0438\u043B\u0438 \u043D\u0430 \u0432\u0430\u0448 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439`
+  },
+  [NotificationType.PostMention]: {
+    one: (name) => `${name} \u0443\u043F\u043E\u043C\u044F\u043D\u0443\u043B(\u0430) \u0432\u0430\u0441 \u0432 \u043F\u043E\u0441\u0442\u0435`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u0443\u043F\u043E\u043C\u044F\u043D\u0443\u043B\u0438 \u0432\u0430\u0441 \u0432 \u043F\u043E\u0441\u0442\u0435`
+  },
+  [NotificationType.CommentMention]: {
+    one: (name) => `${name} \u0443\u043F\u043E\u043C\u044F\u043D\u0443\u043B(\u0430) \u0432\u0430\u0441 \u0432 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u0443\u043F\u043E\u043C\u044F\u043D\u0443\u043B\u0438 \u0432\u0430\u0441 \u0432 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438`
+  },
+  [NotificationType.WallPost]: {
+    one: (name) => `${name} \u043D\u0430\u043F\u0438\u0441\u0430\u043B(\u0430) \u043D\u0430 \u0432\u0430\u0448\u0435\u0439 \u0441\u0442\u0435\u043D\u0435`,
+    many: (name, others) => `${name} \u0438 \u0435\u0449\u0451 ${others} \u043D\u0430\u043F\u0438\u0441\u0430\u043B\u0438 \u043D\u0430 \u0432\u0430\u0448\u0435\u0439 \u0441\u0442\u0435\u043D\u0435`
+  },
+  [NotificationType.VerificationApproved]: {
+    one: () => "\u0412\u0430\u0448\u0430 \u0437\u0430\u044F\u0432\u043A\u0430 \u043D\u0430 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044E \u043E\u0434\u043E\u0431\u0440\u0435\u043D\u0430",
+    many: () => "\u0412\u0430\u0448\u0430 \u0437\u0430\u044F\u0432\u043A\u0430 \u043D\u0430 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044E \u043E\u0434\u043E\u0431\u0440\u0435\u043D\u0430"
+  },
+  [NotificationType.VerificationRejected]: {
+    one: () => "\u0412\u0430\u0448\u0430 \u0437\u0430\u044F\u0432\u043A\u0430 \u043D\u0430 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044E \u043E\u0442\u043A\u043B\u043E\u043D\u0435\u043D\u0430",
+    many: () => "\u0412\u0430\u0448\u0430 \u0437\u0430\u044F\u0432\u043A\u0430 \u043D\u0430 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044E \u043E\u0442\u043A\u043B\u043E\u043D\u0435\u043D\u0430"
+  }
+});
+function formatNotificationText(notification) {
+  const template = TEMPLATES[notification.type];
+  if (!template) return FALLBACK_TEXT;
+  const first = notification.actors[0];
+  const name = first?.displayName || first?.username || UNKNOWN_ACTOR;
+  const others = notification.count - 1;
+  return others > 0 ? template.many(name, others) : template.one(name);
+}
+
+// src/notifications/url.ts
+var POST_TYPES = /* @__PURE__ */ new Set([
+  NotificationType.PostReaction,
+  NotificationType.PostRepost,
+  NotificationType.PostMention,
+  NotificationType.WallPost
+]);
+var COMMENT_TYPES = /* @__PURE__ */ new Set([
+  NotificationType.PostComment,
+  NotificationType.CommentReaction,
+  NotificationType.CommentReply,
+  NotificationType.CommentMention
+]);
+var FOLLOW_TYPES = /* @__PURE__ */ new Set([
+  NotificationType.Follow,
+  NotificationType.FollowRequest,
+  NotificationType.FollowAccepted
+]);
+function resolveNotificationUrl(notification) {
+  const { type, entityId, parentEntityId, clickUrl } = notification;
+  const username = notification.actors[0]?.username;
+  if (username && entityId) {
+    if (POST_TYPES.has(type)) return `/@${username}/post/${entityId}`;
+    if (COMMENT_TYPES.has(type)) {
+      return parentEntityId ? `/@${username}/post/${parentEntityId}?comment=${entityId}` : `/@${username}/post/${entityId}`;
+    }
+  }
+  if (username && FOLLOW_TYPES.has(type)) return `/@${username}`;
+  return clickUrl || "/notifications";
+}
+
+// src/types/models.ts
+function isMyProfile(profile) {
+  return "subscription" in profile;
+}
+function toDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+exports.ALLOWED_MIME_TYPES = ALLOWED_MIME_TYPES;
+exports.AUDIO_MIME_TYPES = AUDIO_MIME_TYPES;
+exports.AttachmentType = AttachmentType;
+exports.CommentSort = CommentSort;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.FeedTab = FeedTab;
+exports.IMAGE_MIME_TYPES = IMAGE_MIME_TYPES;
+exports.ItdAbortError = ItdAbortError;
+exports.ItdApiError = ItdApiError;
+exports.ItdAuthError = ItdAuthError;
+exports.ItdClient = ItdClient;
+exports.ItdConfigError = ItdConfigError;
+exports.ItdConflictError = ItdConflictError;
+exports.ItdError = ItdError;
+exports.ItdErrorCode = ItdErrorCode;
+exports.ItdForbiddenError = ItdForbiddenError;
+exports.ItdNetworkError = ItdNetworkError;
+exports.ItdNotFoundError = ItdNotFoundError;
+exports.ItdPhoneVerificationError = ItdPhoneVerificationError;
+exports.ItdRateLimitError = ItdRateLimitError;
+exports.ItdRealtime = ItdRealtime;
+exports.ItdServerError = ItdServerError;
+exports.ItdTimeoutError = ItdTimeoutError;
+exports.ItdValidationError = ItdValidationError;
+exports.LikesVisibility = LikesVisibility;
+exports.LocalStorageTokenStorage = LocalStorageTokenStorage;
+exports.MAX_RECONNECT_ATTEMPTS = MAX_RECONNECT_ATTEMPTS;
+exports.MemoryTokenStorage = MemoryTokenStorage;
+exports.NOTIFICATION_TYPE_ALIASES = NOTIFICATION_TYPE_ALIASES;
+exports.NotificationType = NotificationType;
+exports.Paginator = Paginator;
+exports.RECONNECT_BACKOFF = RECONNECT_BACKOFF;
+exports.RECONNECT_JITTER = RECONNECT_JITTER;
+exports.RealtimeStatus = RealtimeStatus;
+exports.ReportReason = ReportReason;
+exports.ReportTargetType = ReportTargetType;
+exports.STREAM_PATH = STREAM_PATH;
+exports.VIDEO_MIME_TYPES = VIDEO_MIME_TYPES;
+exports.WallAccess = WallAccess;
+exports.canonicalNotificationType = canonicalNotificationType;
+exports.comment = comment;
+exports.createClient = createClient;
+exports.createTokenStorage = createTokenStorage;
+exports.formatNotificationText = formatNotificationText;
+exports.isBuilder = isBuilder;
+exports.isItdApiError = isItdApiError;
+exports.isItdAuthError = isItdAuthError;
+exports.isItdError = isItdError;
+exports.isItdRateLimitError = isItdRateLimitError;
+exports.isItdValidationError = isItdValidationError;
+exports.isKnownNotificationType = isKnownNotificationType;
+exports.isMyProfile = isMyProfile;
+exports.normalizeNotification = normalizeNotification;
+exports.poll = poll;
+exports.post = post;
+exports.readNotificationEvent = readNotificationEvent;
+exports.readUnreadCountEvent = readUnreadCountEvent;
+exports.report = report;
+exports.resolveNotificationUrl = resolveNotificationUrl;
+exports.toDate = toDate;
+//# sourceMappingURL=chunk-QILCVTJI.cjs.map
+//# sourceMappingURL=chunk-QILCVTJI.cjs.map