ani-client 1.4.4 → 1.5.1

package/dist/index.js

@@ -1,6 +1,139 @@
 'use strict';
 
-// src/queries/index.ts
+// src/utils/markdown.ts
+function parseAniListMarkdown(text) {
+  if (!text) return "";
+  let html = text;
+  html = html.replace(/~!(.*?)!~/gs, '<span class="anilist-spoiler">$1</span>');
+  html = html.replace(/~~~(.*?)~~~/gs, '<div class="anilist-center">$1</div>');
+  html = html.replace(/img(\d+)\((.*?)\)/gi, '<img src="$2" width="$1" alt="" class="anilist-image" />');
+  html = html.replace(/img\((.*?)\)/gi, '<img src="$1" alt="" class="anilist-image" />');
+  html = html.replace(
+    /youtube\((.*?)\)/gi,
+    '<iframe src="https://www.youtube.com/embed/$1" frameborder="0" allowfullscreen class="anilist-youtube"></iframe>'
+  );
+  html = html.replace(/webm\((.*?)\)/gi, '<video src="$1" controls class="anilist-webm"></video>');
+  html = html.replace(/__(.*?)__/g, "<strong>$1</strong>");
+  html = html.replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/_(.*?)_/g, "<em>$1</em>");
+  html = html.replace(/(?<!\*)\*(?!\*)(.*?)(?<!\*)\*(?!\*)/g, "<em>$1</em>");
+  html = html.replace(/~~(.*?)~~/g, "<del>$1</del>");
+  html = html.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
+  html = html.replace(/\r\n/g, "\n");
+  const paragraphs = html.split(/\n{2,}/);
+  html = paragraphs.map((p) => {
+    const withBr = p.replace(/\n/g, "<br />");
+    if (withBr.match(/^(<div|<iframe|<video|<img)/)) {
+      return withBr;
+    }
+    return `<p>${withBr}</p>`;
+  }).join("\n");
+  return html;
+}
+
+// src/utils/index.ts
+function normalizeQuery(query) {
+  return query.replace(/\s+/g, " ").trim();
+}
+function clampPerPage(value) {
+  return Math.min(Math.max(value, 1), 50);
+}
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+
+// src/cache/index.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var MemoryCache = class {
+  constructor(options = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.ttl = options.ttl ?? ONE_DAY_MS;
+    this.maxSize = options.maxSize ?? 500;
+    this.enabled = options.enabled ?? true;
+  }
+  /** Build a deterministic cache key from a query + variables pair. */
+  static key(query, variables) {
+    const normalized = normalizeQuery(query);
+    return `${normalized}|${JSON.stringify(variables, Object.keys(variables).sort())}`;
+  }
+  /** Retrieve a cached value, or `undefined` if missing / expired. */
+  get(key) {
+    if (!this.enabled) return void 0;
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry.data;
+  }
+  /** Store a value in the cache. */
+  set(key, data) {
+    if (!this.enabled) return;
+    this.store.delete(key);
+    if (this.maxSize > 0 && this.store.size >= this.maxSize) {
+      const firstKey = this.store.keys().next().value;
+      if (firstKey !== void 0) this.store.delete(firstKey);
+    }
+    this.store.set(key, { data, expiresAt: Date.now() + this.ttl });
+  }
+  /** Remove a specific entry. */
+  delete(key) {
+    return this.store.delete(key);
+  }
+  /** Clear the entire cache. */
+  clear() {
+    this.store.clear();
+  }
+  /** Number of entries currently stored. */
+  get size() {
+    return this.store.size;
+  }
+  /** Return all cache keys. */
+  keys() {
+    return [...this.store.keys()];
+  }
+  /**
+   * Remove all entries whose key matches the given pattern.
+   *
+   * - **String**: treated as a substring match (e.g. `"Media"` removes all keys containing `"Media"`).
+   * - **RegExp**: tested against each key directly.
+   *
+   * @param pattern — A string (substring match) or RegExp.
+   * @returns Number of entries removed.
+   */
+  invalidate(pattern) {
+    const test = typeof pattern === "string" ? (key) => key.includes(pattern) : (key) => pattern.test(key);
+    const toDelete = [];
+    for (const key of this.store.keys()) {
+      if (test(key)) toDelete.push(key);
+    }
+    for (const key of toDelete) this.store.delete(key);
+    return toDelete.length;
+  }
+};
+
+// src/errors/index.ts
+var AniListError = class _AniListError extends Error {
+  constructor(message, status, errors = []) {
+    super(message);
+    this.name = "AniListError";
+    this.status = status;
+    this.errors = errors;
+    Object.setPrototypeOf(this, _AniListError.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AniListError);
+    }
+  }
+};
+
+// src/queries/fragments.ts
 var MEDIA_FIELDS_BASE = `
   id
   idMal
@@ -35,6 +168,13 @@ var MEDIA_FIELDS_BASE = `
   studios { nodes { id name isAnimationStudio siteUrl } }
   isAdult
   siteUrl
+  nextAiringEpisode {
+    id
+    airingAt
+    episode
+    mediaId
+    timeUntilAiring
+  }
 `;
 var RELATIONS_FIELDS = `
   relations {
@@ -186,6 +326,45 @@ var USER_FIELDS = `
     manga { count meanScore minutesWatched episodesWatched chaptersRead volumesRead }
   }
 `;
+var MEDIA_LIST_FIELDS = `
+  id
+  mediaId
+  status
+  score(format: POINT_100)
+  progress
+  progressVolumes
+  repeat
+  priority
+  private
+  notes
+  startedAt { year month day }
+  completedAt { year month day }
+  updatedAt
+  createdAt
+  media {
+    ${MEDIA_FIELDS_BASE}
+  }
+`;
+var STUDIO_FIELDS = `
+  id
+  name
+  isAnimationStudio
+  siteUrl
+  favourites
+  media(page: 1, perPage: 25, sort: POPULARITY_DESC) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    nodes {
+      id
+      title { romaji english native userPreferred }
+      type
+      format
+      coverImage { large medium }
+      siteUrl
+    }
+  }
+`;
+
+// src/queries/media.ts
 var QUERY_MEDIA_BY_ID = `
 query ($id: Int!) {
   Media(id: $id) {
@@ -202,6 +381,10 @@ query (
   $seasonYear: Int,
   $genre: String,
   $tag: String,
+  $genre_in: [String],
+  $tag_in: [String],
+  $genre_not_in: [String],
+  $tag_not_in: [String],
   $isAdult: Boolean,
   $sort: [MediaSort],
   $page: Int,
@@ -218,6 +401,10 @@ query (
       seasonYear: $seasonYear,
       genre: $genre,
       tag: $tag,
+      genre_in: $genre_in,
+      tag_in: $tag_in,
+      genre_not_in: $genre_not_in,
+      tag_not_in: $tag_not_in,
       isAdult: $isAdult,
       sort: $sort
     ) {
@@ -234,70 +421,6 @@ query ($type: MediaType, $page: Int, $perPage: Int) {
     }
   }
 }`;
-var QUERY_CHARACTER_BY_ID = `
-query ($id: Int!) {
-  Character(id: $id) {
-    ${CHARACTER_FIELDS}
-  }
-}`;
-var QUERY_CHARACTER_BY_ID_WITH_VA = `
-query ($id: Int!) {
-  Character(id: $id) {
-    ${CHARACTER_FIELDS_WITH_VA}
-  }
-}`;
-var QUERY_CHARACTER_SEARCH = `
-query ($search: String, $sort: [CharacterSort], $page: Int, $perPage: Int) {
-  Page(page: $page, perPage: $perPage) {
-    pageInfo { total perPage currentPage lastPage hasNextPage }
-    characters(search: $search, sort: $sort) {
-      ${CHARACTER_FIELDS}
-    }
-  }
-}`;
-var QUERY_CHARACTER_SEARCH_WITH_VA = `
-query ($search: String, $sort: [CharacterSort], $page: Int, $perPage: Int) {
-  Page(page: $page, perPage: $perPage) {
-    pageInfo { total perPage currentPage lastPage hasNextPage }
-    characters(search: $search, sort: $sort) {
-      ${CHARACTER_FIELDS_WITH_VA}
-    }
-  }
-}`;
-var QUERY_STAFF_BY_ID = `
-query ($id: Int!) {
-  Staff(id: $id) {
-    ${STAFF_FIELDS}
-  }
-}`;
-var QUERY_STAFF_BY_ID_WITH_MEDIA = `
-query ($id: Int!, $perPage: Int) {
-  Staff(id: $id) {
-    ${STAFF_FIELDS}
-    ${STAFF_MEDIA_FIELDS}
-  }
-}`;
-var QUERY_STAFF_SEARCH = `
-query ($search: String, $sort: [StaffSort], $page: Int, $perPage: Int) {
-  Page(page: $page, perPage: $perPage) {
-    pageInfo { total perPage currentPage lastPage hasNextPage }
-    staff(search: $search, sort: $sort) {
-      ${STAFF_FIELDS}
-    }
-  }
-}`;
-var QUERY_USER_BY_ID = `
-query ($id: Int!) {
-  User(id: $id) {
-    ${USER_FIELDS}
-  }
-}`;
-var QUERY_USER_BY_NAME = `
-query ($name: String!) {
-  User(name: $name) {
-    ${USER_FIELDS}
-  }
-}`;
 var QUERY_AIRING_SCHEDULE = `
 query ($airingAt_greater: Int, $airingAt_lesser: Int, $sort: [AiringSort], $page: Int, $perPage: Int) {
   Page(page: $page, perPage: $perPage) {
@@ -341,25 +464,6 @@ query ($season: MediaSeason!, $seasonYear: Int!, $type: MediaType, $sort: [Media
     }
   }
 }`;
-var MEDIA_LIST_FIELDS = `
-  id
-  mediaId
-  status
-  score(format: POINT_100)
-  progress
-  progressVolumes
-  repeat
-  priority
-  private
-  notes
-  startedAt { year month day }
-  completedAt { year month day }
-  updatedAt
-  createdAt
-  media {
-    ${MEDIA_FIELDS_BASE}
-  }
-`;
 var QUERY_RECOMMENDATIONS = `
 query ($mediaId: Int!, $page: Int, $perPage: Int, $sort: [RecommendationSort]) {
   Media(id: $mediaId) {
@@ -394,6 +498,85 @@ query ($mediaId: Int!, $page: Int, $perPage: Int, $sort: [RecommendationSort]) {
     }
   }
 }`;
+
+// src/queries/character.ts
+var QUERY_CHARACTER_BY_ID = `
+query ($id: Int!) {
+  Character(id: $id) {
+    ${CHARACTER_FIELDS}
+  }
+}`;
+var QUERY_CHARACTER_BY_ID_WITH_VA = `
+query ($id: Int!) {
+  Character(id: $id) {
+    ${CHARACTER_FIELDS_WITH_VA}
+  }
+}`;
+var QUERY_CHARACTER_SEARCH = `
+query ($search: String, $sort: [CharacterSort], $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    characters(search: $search, sort: $sort) {
+      ${CHARACTER_FIELDS}
+    }
+  }
+}`;
+var QUERY_CHARACTER_SEARCH_WITH_VA = `
+query ($search: String, $sort: [CharacterSort], $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    characters(search: $search, sort: $sort) {
+      ${CHARACTER_FIELDS_WITH_VA}
+    }
+  }
+}`;
+
+// src/queries/staff.ts
+var QUERY_STAFF_BY_ID = `
+query ($id: Int!) {
+  Staff(id: $id) {
+    ${STAFF_FIELDS}
+  }
+}`;
+var QUERY_STAFF_BY_ID_WITH_MEDIA = `
+query ($id: Int!, $perPage: Int) {
+  Staff(id: $id) {
+    ${STAFF_FIELDS}
+    ${STAFF_MEDIA_FIELDS}
+  }
+}`;
+var QUERY_STAFF_SEARCH = `
+query ($search: String, $sort: [StaffSort], $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    staff(search: $search, sort: $sort) {
+      ${STAFF_FIELDS}
+    }
+  }
+}`;
+
+// src/queries/user.ts
+var QUERY_USER_BY_ID = `
+query ($id: Int!) {
+  User(id: $id) {
+    ${USER_FIELDS}
+  }
+}`;
+var QUERY_USER_BY_NAME = `
+query ($name: String!) {
+  User(name: $name) {
+    ${USER_FIELDS}
+  }
+}`;
+var QUERY_USER_SEARCH = `
+query ($search: String, $sort: [UserSort], $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    users(search: $search, sort: $sort) {
+      ${USER_FIELDS}
+    }
+  }
+}`;
 var QUERY_USER_MEDIA_LIST = `
 query ($userId: Int, $userName: String, $type: MediaType!, $status: MediaListStatus, $sort: [MediaListSort], $page: Int, $perPage: Int) {
   Page(page: $page, perPage: $perPage) {
@@ -403,24 +586,8 @@ query ($userId: Int, $userName: String, $type: MediaType!, $status: MediaListSta
     }
   }
 }`;
-var STUDIO_FIELDS = `
-  id
-  name
-  isAnimationStudio
-  siteUrl
-  favourites
-  media(page: 1, perPage: 25, sort: POPULARITY_DESC) {
-    pageInfo { total perPage currentPage lastPage hasNextPage }
-    nodes {
-      id
-      title { romaji english native userPreferred }
-      type
-      format
-      coverImage { large medium }
-      siteUrl
-    }
-  }
-`;
+
+// src/queries/studio.ts
 var QUERY_STUDIO_BY_ID = `
 query ($id: Int!) {
   Studio(id: $id) {
@@ -436,6 +603,8 @@ query ($search: String, $page: Int, $perPage: Int) {
     }
   }
 }`;
+
+// src/queries/metadata.ts
 var QUERY_GENRES = `
 query {
   GenreCollection
@@ -450,6 +619,8 @@ query {
     isAdult
   }
 }`;
+
+// src/queries/builders.ts
 function buildMediaByIdQuery(include) {
   if (!include) return QUERY_MEDIA_BY_ID;
   const extra = [];
@@ -552,95 +723,70 @@ var buildBatchMediaQuery = (ids) => buildBatchQuery(ids, "Media", MEDIA_FIELDS_B
 var buildBatchCharacterQuery = (ids) => buildBatchQuery(ids, "Character", CHARACTER_FIELDS, "c");
 var buildBatchStaffQuery = (ids) => buildBatchQuery(ids, "Staff", STAFF_FIELDS, "s");
 
-// src/cache/index.ts
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var MemoryCache = class {
-  constructor(options = {}) {
-    this.store = /* @__PURE__ */ new Map();
-    this.ttl = options.ttl ?? ONE_DAY_MS;
-    this.maxSize = options.maxSize ?? 500;
-    this.enabled = options.enabled ?? true;
-  }
-  /** Build a deterministic cache key from a query + variables pair. */
-  static key(query, variables) {
-    const normalized = query.replace(/\s+/g, " ").trim();
-    return `${normalized}|${JSON.stringify(variables, Object.keys(variables).sort())}`;
-  }
-  /** Retrieve a cached value, or `undefined` if missing / expired. */
-  get(key) {
-    if (!this.enabled) return void 0;
-    const entry = this.store.get(key);
-    if (!entry) return void 0;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return void 0;
-    }
-    this.store.delete(key);
-    this.store.set(key, entry);
-    return entry.data;
-  }
-  /** Store a value in the cache. */
-  set(key, data) {
-    if (!this.enabled) return;
-    this.store.delete(key);
-    if (this.maxSize > 0 && this.store.size >= this.maxSize) {
-      const firstKey = this.store.keys().next().value;
-      if (firstKey !== void 0) this.store.delete(firstKey);
-    }
-    this.store.set(key, { data, expiresAt: Date.now() + this.ttl });
+// src/queries/thread.ts
+var THREAD_FIELDS = `
+  id
+  title
+  body(asHtml: false)
+  userId
+  replyUserId
+  replyCommentId
+  replyCount
+  viewCount
+  isLocked
+  isSticky
+  isSubscribed
+  repliedAt
+  createdAt
+  updatedAt
+  siteUrl
+  user {
+    id
+    name
+    avatar { large medium }
   }
-  /** Remove a specific entry. */
-  delete(key) {
-    return this.store.delete(key);
+  replyUser {
+    id
+    name
+    avatar { large medium }
   }
-  /** Clear the entire cache. */
-  clear() {
-    this.store.clear();
+  categories {
+    id
+    name
   }
-  /** Number of entries currently stored. */
-  get size() {
-    return this.store.size;
+  mediaCategories {
+    id
+    title { romaji english native userPreferred }
+    type
+    coverImage { large medium }
+    siteUrl
   }
-  /** Return all cache keys. */
-  keys() {
-    return [...this.store.keys()];
+  likes {
+    id
+    name
   }
-  /**
-   * Remove all entries whose key matches the given pattern.
-   *
-   * @param pattern — A string (converted to RegExp) or RegExp.
-   * @returns Number of entries removed.
-   */
-  invalidate(pattern) {
-    const regex = typeof pattern === "string" ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")) : pattern;
-    const toDelete = [];
-    for (const key of this.store.keys()) {
-      if (regex.test(key)) toDelete.push(key);
-    }
-    for (const key of toDelete) this.store.delete(key);
-    return toDelete.length;
+`;
+var QUERY_THREAD_BY_ID = `
+query ($id: Int!) {
+  Thread(id: $id) {
+    ${THREAD_FIELDS}
   }
-};
-
-// src/errors/index.ts
-var AniListError = class _AniListError extends Error {
-  constructor(message, status, errors = []) {
-    super(message);
-    this.name = "AniListError";
-    this.status = status;
-    this.errors = errors;
-    Object.setPrototypeOf(this, _AniListError.prototype);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _AniListError);
+}`;
+var QUERY_THREAD_SEARCH = `
+query ($search: String, $mediaCategoryId: Int, $categoryId: Int, $sort: [ThreadSort], $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    pageInfo { total perPage currentPage lastPage hasNextPage }
+    threads(search: $search, mediaCategoryId: $mediaCategoryId, categoryId: $categoryId, sort: $sort) {
+      ${THREAD_FIELDS}
     }
   }
-};
+}`;
 
 // src/rate-limiter/index.ts
 var RateLimiter = class {
   constructor(options = {}) {
-    /** @internal */
-    this.timestamps = [];
+    this.head = 0;
+    this.count = 0;
     this.maxRequests = options.maxRequests ?? 85;
     this.windowMs = options.windowMs ?? 6e4;
     this.maxRetries = options.maxRetries ?? 3;
@@ -648,24 +794,34 @@ var RateLimiter = class {
     this.enabled = options.enabled ?? true;
     this.timeoutMs = options.timeoutMs ?? 3e4;
     this.retryOnNetworkError = options.retryOnNetworkError ?? true;
+    this.timestamps = new Array(this.maxRequests).fill(0);
   }
   /**
    * Wait until it's safe to make a request (respects rate limit window).
    */
   async acquire() {
     if (!this.enabled) return;
+    if (this.count >= this.maxRequests) {
+      const oldest = this.timestamps[this.head];
+      const now2 = Date.now();
+      const elapsed = now2 - oldest;
+      if (elapsed < this.windowMs) {
+        const waitMs = this.windowMs - elapsed + 50;
+        await this.sleep(waitMs);
+      }
+    }
     const now = Date.now();
-    this.timestamps = this.timestamps.filter((t) => now - t < this.windowMs);
-    if (this.timestamps.length >= this.maxRequests) {
-      const oldest = this.timestamps[0];
-      const waitMs = this.windowMs - (now - oldest) + 50;
-      await this.sleep(waitMs);
-      return this.acquire();
+    if (this.count < this.maxRequests) {
+      this.timestamps[(this.head + this.count) % this.maxRequests] = now;
+      this.count++;
+    } else {
+      this.timestamps[this.head] = now;
+      this.head = (this.head + 1) % this.maxRequests;
     }
-    this.timestamps.push(Date.now());
   }
   /**
    * Execute a fetch with automatic retry on 429 responses and network errors.
+   * Uses exponential backoff with jitter for retry delays.
    */
   async fetchWithRetry(url, init, hooks) {
     await this.acquire();
@@ -678,7 +834,7 @@ var RateLimiter = class {
         lastResponse = res;
         if (attempt === this.maxRetries) break;
         const retryAfter = res.headers.get("Retry-After");
-        const delayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : this.retryDelayMs * (attempt + 1);
+        const delayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : this.exponentialDelay(attempt);
         hooks?.onRateLimit?.(delayMs);
         hooks?.onRetry?.(attempt + 1, "HTTP 429", delayMs);
         await this.sleep(delayMs);
@@ -686,7 +842,7 @@ var RateLimiter = class {
       } catch (err) {
         lastError = err;
         if (this.retryOnNetworkError && isNetworkError(err) && attempt < this.maxRetries) {
-          const delayMs = this.retryDelayMs * (attempt + 1);
+          const delayMs = this.exponentialDelay(attempt);
           hooks?.onRetry?.(attempt + 1, `Network error: ${err.message}`, delayMs);
           await this.sleep(delayMs);
           await this.acquire();
@@ -698,6 +854,12 @@ var RateLimiter = class {
     if (lastResponse) return lastResponse;
     throw lastError;
   }
+  /** @internal — Exponential backoff with jitter, capped at 30s */
+  exponentialDelay(attempt) {
+    const base = this.retryDelayMs * 2 ** attempt;
+    const jitter = Math.random() * 1e3;
+    return Math.min(base + jitter, 3e4);
+  }
   /** @internal */
   async fetchWithTimeout(url, init) {
     if (this.timeoutMs <= 0) return fetch(url, init);
@@ -731,12 +893,42 @@ function isNetworkError(err) {
   return false;
 }
 
+// src/client/character.ts
+async function getCharacter(client, id, include) {
+  const query = include?.voiceActors ? QUERY_CHARACTER_BY_ID_WITH_VA : QUERY_CHARACTER_BY_ID;
+  const data = await client.request(query, { id });
+  return data.Character;
+}
+async function searchCharacters(client, options = {}) {
+  const { query: search, page = 1, perPage = 20, sort, voiceActors } = options;
+  const gqlQuery = voiceActors ? QUERY_CHARACTER_SEARCH_WITH_VA : QUERY_CHARACTER_SEARCH;
+  return client.pagedRequest(gqlQuery, { search, sort, page, perPage: clampPerPage(perPage) }, "characters");
+}
+
 // src/types/media.ts
 var MediaType = /* @__PURE__ */ ((MediaType2) => {
   MediaType2["ANIME"] = "ANIME";
   MediaType2["MANGA"] = "MANGA";
   return MediaType2;
 })(MediaType || {});
+var MediaSource = /* @__PURE__ */ ((MediaSource2) => {
+  MediaSource2["ORIGINAL"] = "ORIGINAL";
+  MediaSource2["MANGA"] = "MANGA";
+  MediaSource2["LIGHT_NOVEL"] = "LIGHT_NOVEL";
+  MediaSource2["VISUAL_NOVEL"] = "VISUAL_NOVEL";
+  MediaSource2["VIDEO_GAME"] = "VIDEO_GAME";
+  MediaSource2["OTHER"] = "OTHER";
+  MediaSource2["NOVEL"] = "NOVEL";
+  MediaSource2["DOUJINSHI"] = "DOUJINSHI";
+  MediaSource2["ANIME"] = "ANIME";
+  MediaSource2["WEB_NOVEL"] = "WEB_NOVEL";
+  MediaSource2["LIVE_ACTION"] = "LIVE_ACTION";
+  MediaSource2["GAME"] = "GAME";
+  MediaSource2["COMIC"] = "COMIC";
+  MediaSource2["MULTIMEDIA_PROJECT"] = "MULTIMEDIA_PROJECT";
+  MediaSource2["PICTURE_BOOK"] = "PICTURE_BOOK";
+  return MediaSource2;
+})(MediaSource || {});
 var MediaFormat = /* @__PURE__ */ ((MediaFormat2) => {
   MediaFormat2["TV"] = "TV";
   MediaFormat2["TV_SHORT"] = "TV_SHORT";
@@ -869,6 +1061,20 @@ var StaffSort = /* @__PURE__ */ ((StaffSort2) => {
   return StaffSort2;
 })(StaffSort || {});
 
+// src/types/user.ts
+var UserSort = /* @__PURE__ */ ((UserSort2) => {
+  UserSort2["ID"] = "ID";
+  UserSort2["ID_DESC"] = "ID_DESC";
+  UserSort2["USERNAME"] = "USERNAME";
+  UserSort2["USERNAME_DESC"] = "USERNAME_DESC";
+  UserSort2["WATCHED_TIME"] = "WATCHED_TIME";
+  UserSort2["WATCHED_TIME_DESC"] = "WATCHED_TIME_DESC";
+  UserSort2["CHAPTERS_READ"] = "CHAPTERS_READ";
+  UserSort2["CHAPTERS_READ_DESC"] = "CHAPTERS_READ_DESC";
+  UserSort2["SEARCH_MATCH"] = "SEARCH_MATCH";
+  return UserSort2;
+})(UserSort || {});
+
 // src/types/lists.ts
 var MediaListStatus = /* @__PURE__ */ ((MediaListStatus2) => {
   MediaListStatus2["CURRENT"] = "CURRENT";
@@ -913,16 +1119,245 @@ var MediaListSort = /* @__PURE__ */ ((MediaListSort2) => {
   return MediaListSort2;
 })(MediaListSort || {});
 
-// src/utils/index.ts
-function clampPerPage(value) {
-  return Math.min(Math.max(value, 1), 50);
+// src/types/thread.ts
+var ThreadSort = /* @__PURE__ */ ((ThreadSort2) => {
+  ThreadSort2["ID"] = "ID";
+  ThreadSort2["ID_DESC"] = "ID_DESC";
+  ThreadSort2["TITLE"] = "TITLE";
+  ThreadSort2["TITLE_DESC"] = "TITLE_DESC";
+  ThreadSort2["CREATED_AT"] = "CREATED_AT";
+  ThreadSort2["CREATED_AT_DESC"] = "CREATED_AT_DESC";
+  ThreadSort2["UPDATED_AT"] = "UPDATED_AT";
+  ThreadSort2["UPDATED_AT_DESC"] = "UPDATED_AT_DESC";
+  ThreadSort2["REPLIED_AT"] = "REPLIED_AT";
+  ThreadSort2["REPLIED_AT_DESC"] = "REPLIED_AT_DESC";
+  ThreadSort2["REPLY_COUNT"] = "REPLY_COUNT";
+  ThreadSort2["REPLY_COUNT_DESC"] = "REPLY_COUNT_DESC";
+  ThreadSort2["VIEW_COUNT"] = "VIEW_COUNT";
+  ThreadSort2["VIEW_COUNT_DESC"] = "VIEW_COUNT_DESC";
+  ThreadSort2["IS_STICKY"] = "IS_STICKY";
+  ThreadSort2["SEARCH_MATCH"] = "SEARCH_MATCH";
+  return ThreadSort2;
+})(ThreadSort || {});
+
+// src/client/media.ts
+async function getMedia(client, id, include) {
+  const query = buildMediaByIdQuery(include);
+  const data = await client.request(query, { id });
+  return data.Media;
 }
-function chunk(arr, size) {
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
-  }
-  return chunks;
+async function searchMedia(client, options = {}) {
+  const { query: search, page = 1, perPage = 20, genres, tags, genresExclude, tagsExclude, ...filters } = options;
+  return client.pagedRequest(
+    QUERY_MEDIA_SEARCH,
+    {
+      search,
+      ...filters,
+      genre_in: genres,
+      tag_in: tags,
+      genre_not_in: genresExclude,
+      tag_not_in: tagsExclude,
+      page,
+      perPage: clampPerPage(perPage)
+    },
+    "media"
+  );
+}
+async function getTrending(client, type = "ANIME" /* ANIME */, page = 1, perPage = 20) {
+  return client.pagedRequest(QUERY_TRENDING, { type, page, perPage: clampPerPage(perPage) }, "media");
+}
+async function getPopular(client, type = "ANIME" /* ANIME */, page = 1, perPage = 20) {
+  return searchMedia(client, { type, sort: ["POPULARITY_DESC" /* POPULARITY_DESC */], page, perPage });
+}
+async function getTopRated(client, type = "ANIME" /* ANIME */, page = 1, perPage = 20) {
+  return searchMedia(client, { type, sort: ["SCORE_DESC" /* SCORE_DESC */], page, perPage });
+}
+async function getAiredEpisodes(client, options = {}) {
+  const now = Math.floor(Date.now() / 1e3);
+  return client.pagedRequest(
+    QUERY_AIRING_SCHEDULE,
+    {
+      airingAt_greater: options.airingAtGreater ?? now - 24 * 3600,
+      airingAt_lesser: options.airingAtLesser ?? now,
+      sort: options.sort,
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "airingSchedules"
+  );
+}
+async function getAiredChapters(client, options = {}) {
+  return client.pagedRequest(
+    QUERY_RECENT_CHAPTERS,
+    {
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "media"
+  );
+}
+async function getPlanning(client, options = {}) {
+  return client.pagedRequest(
+    QUERY_PLANNING,
+    {
+      type: options.type,
+      sort: options.sort ?? ["POPULARITY_DESC" /* POPULARITY_DESC */],
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "media"
+  );
+}
+async function getRecommendations(client, mediaId, options = {}) {
+  const data = await client.request(QUERY_RECOMMENDATIONS, {
+    mediaId,
+    page: options.page ?? 1,
+    perPage: clampPerPage(options.perPage ?? 20),
+    sort: options.sort
+  });
+  return {
+    pageInfo: data.Media.recommendations.pageInfo,
+    results: data.Media.recommendations.nodes
+  };
+}
+async function getMediaBySeason(client, options) {
+  return client.pagedRequest(
+    QUERY_MEDIA_BY_SEASON,
+    {
+      season: options.season,
+      seasonYear: options.seasonYear,
+      type: options.type,
+      sort: options.sort,
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "media"
+  );
+}
+async function getWeeklySchedule(client, date = /* @__PURE__ */ new Date()) {
+  const schedule = {
+    Monday: [],
+    Tuesday: [],
+    Wednesday: [],
+    Thursday: [],
+    Friday: [],
+    Saturday: [],
+    Sunday: []
+  };
+  const startOfWeek = new Date(date);
+  const day = startOfWeek.getDay();
+  const diff = startOfWeek.getDate() - day + (day === 0 ? -6 : 1);
+  startOfWeek.setDate(diff);
+  startOfWeek.setHours(0, 0, 0, 0);
+  const endOfWeek = new Date(startOfWeek);
+  endOfWeek.setDate(startOfWeek.getDate() + 6);
+  endOfWeek.setHours(23, 59, 59, 999);
+  const startTimestamp = Math.floor(startOfWeek.getTime() / 1e3);
+  const endTimestamp = Math.floor(endOfWeek.getTime() / 1e3);
+  const iterator = client.paginate(
+    (page) => getAiredEpisodes(client, {
+      airingAtGreater: startTimestamp,
+      airingAtLesser: endTimestamp,
+      page,
+      perPage: 50
+    })
+  );
+  for await (const episode of iterator) {
+    const epDate = new Date(episode.airingAt * 1e3);
+    const names = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    const dayName = names[epDate.getDay()];
+    schedule[dayName].push(episode);
+  }
+  return schedule;
+}
+
+// src/client/staff.ts
+async function getStaff(client, id, include) {
+  if (include?.media) {
+    const perPage = typeof include.media === "object" ? include.media.perPage ?? 25 : 25;
+    const data2 = await client.request(QUERY_STAFF_BY_ID_WITH_MEDIA, { id, perPage });
+    return data2.Staff;
+  }
+  const data = await client.request(QUERY_STAFF_BY_ID, { id });
+  return data.Staff;
+}
+async function searchStaff(client, options = {}) {
+  const { query: search, page = 1, perPage = 20, sort } = options;
+  return client.pagedRequest(
+    QUERY_STAFF_SEARCH,
+    { search, sort, page, perPage: clampPerPage(perPage) },
+    "staff"
+  );
+}
+
+// src/client/studio.ts
+async function getStudio(client, id) {
+  const data = await client.request(QUERY_STUDIO_BY_ID, { id });
+  return data.Studio;
+}
+async function searchStudios(client, options = {}) {
+  return client.pagedRequest(
+    QUERY_STUDIO_SEARCH,
+    {
+      search: options.query,
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "studios"
+  );
+}
+
+// src/client/thread.ts
+async function getThread(client, id) {
+  const data = await client.request(QUERY_THREAD_BY_ID, { id });
+  return data.Thread;
+}
+async function getRecentThreads(client, options = {}) {
+  const { query: search, page = 1, perPage = 20, sort, mediaId, categoryId } = options;
+  return client.pagedRequest(
+    QUERY_THREAD_SEARCH,
+    {
+      search,
+      mediaCategoryId: mediaId,
+      categoryId,
+      sort: sort ?? ["REPLIED_AT_DESC" /* REPLIED_AT_DESC */],
+      page,
+      perPage: clampPerPage(perPage)
+    },
+    "threads"
+  );
+}
+
+// src/client/user.ts
+async function getUser(client, idOrName) {
+  if (typeof idOrName === "number") {
+    const data2 = await client.request(QUERY_USER_BY_ID, { id: idOrName });
+    return data2.User;
+  }
+  const data = await client.request(QUERY_USER_BY_NAME, { name: idOrName });
+  return data.User;
+}
+async function searchUsers(client, options = {}) {
+  const { query: search, page = 1, perPage = 20, sort } = options;
+  return client.pagedRequest(QUERY_USER_SEARCH, { search, sort, page, perPage: clampPerPage(perPage) }, "users");
+}
+async function getUserMediaList(client, options) {
+  if (!options.userId && !options.userName) {
+    throw new AniListError("getUserMediaList requires either userId or userName", 0, []);
+  }
+  return client.pagedRequest(
+    QUERY_USER_MEDIA_LIST,
+    {
+      userId: options.userId,
+      userName: options.userName,
+      type: options.type,
+      status: options.status,
+      sort: options.sort,
+      page: options.page ?? 1,
+      perPage: clampPerPage(options.perPage ?? 20)
+    },
+    "mediaList"
+  );
 }
 
 // src/client/index.ts
@@ -942,9 +1377,8 @@ var AniListClient = class {
     this.rateLimiter = new RateLimiter(options.rateLimit);
     this.hooks = options.hooks ?? {};
   }
-  /**
-   * @internal
-   */
+  // ── Core infrastructure (internal) ──
+  /** @internal */
   async request(query, variables = {}) {
     const cacheKey = MemoryCache.key(query, variables);
     const cached = await this.cacheAdapter.get(cacheKey);
@@ -967,7 +1401,7 @@ var AniListClient = class {
   async executeRequest(query, variables, cacheKey) {
     const start = Date.now();
     this.hooks.onRequest?.(query, variables);
-    const minifiedQuery = query.replace(/\s+/g, " ").trim();
+    const minifiedQuery = normalizeQuery(query);
     const res = await this.rateLimiter.fetchWithRetry(
       this.apiUrl,
       {
@@ -987,10 +1421,7 @@ var AniListClient = class {
     this.hooks.onResponse?.(query, Date.now() - start, false);
     return data;
   }
-  /**
-   * @internal
-   * Shorthand for paginated queries that follow the `Page { pageInfo, <field>[] }` pattern.
-   */
+  /** @internal */
   async pagedRequest(query, variables, field) {
     const data = await this.request(query, variables);
     const results = data.Page[field];
@@ -999,6 +1430,7 @@ var AniListClient = class {
     }
     return { pageInfo: data.Page.pageInfo, results };
   }
+  // ── Media ──
   /**
    * Fetch a single media entry by its AniList ID.
    *
@@ -1006,467 +1438,130 @@ var AniListClient = class {
    *
    * @param id - The AniList media ID
    * @param include - Optional related data to include
-   * @returns The media object
-   *
-   * @example
-   * ```ts
-   * // Basic usage — same as before (includes relations by default)
-   * const anime = await client.getMedia(1);
-   *
-   * // Include characters sorted by role, 25 results
-   * const anime = await client.getMedia(1, { characters: true });
-   *
-   * // Include characters with voice actors
-   * const anime = await client.getMedia(1, { characters: { voiceActors: true } });
-   *
-   * // Full control
-   * const anime = await client.getMedia(1, {
-   *   characters: { perPage: 50, sort: true },
-   *   staff: true,
-   *   relations: true,
-   *   streamingEpisodes: true,
-   *   externalLinks: true,
-   *   stats: true,
-   *   recommendations: { perPage: 5 },
-   * });
-   *
-   * // Exclude relations for a lighter response
-   * const anime = await client.getMedia(1, { characters: true, relations: false });
-   * ```
    */
   async getMedia(id, include) {
-    const query = include ? buildMediaByIdQuery(include) : QUERY_MEDIA_BY_ID;
-    const data = await this.request(query, { id });
-    return data.Media;
+    return getMedia(this, id, include);
   }
   /**
    * Search for anime or manga.
    *
    * @param options - Search / filter parameters
    * @returns Paginated results with matching media
-   *
-   * @example
-   * ```ts
-   * const results = await client.searchMedia({
-   *   query: "Naruto",
-   *   type: MediaType.ANIME,
-   *   perPage: 5,
-   * });
-   * ```
    */
   async searchMedia(options = {}) {
-    const { query: search, page = 1, perPage = 20, ...filters } = options;
-    return this.pagedRequest(
-      QUERY_MEDIA_SEARCH,
-      { search, ...filters, page, perPage: clampPerPage(perPage) },
-      "media"
-    );
-  }
-  /**
-   * Get currently trending anime or manga.
-   *
-   * @param type - `MediaType.ANIME` or `MediaType.MANGA` (defaults to ANIME)
-   * @param page - Page number (default 1)
-   * @param perPage - Results per page (default 20, max 50)
-   */
-  async getTrending(type = "ANIME" /* ANIME */, page = 1, perPage = 20) {
-    return this.pagedRequest(QUERY_TRENDING, { type, page, perPage: clampPerPage(perPage) }, "media");
-  }
-  /**
-   * Fetch a character by AniList ID.
-   *
-   * @param id - The AniList character ID
-   * @param include - Optional include options (e.g. voice actors)
-   * @returns The character object
-   *
-   * @example
-   * ```ts
-   * const spike = await client.getCharacter(1);
-   * console.log(spike.name.full); // "Spike Spiegel"
-   *
-   * // With voice actors
-   * const spike = await client.getCharacter(1, { voiceActors: true });
-   * spike.media?.edges?.forEach((e) => {
-   *   console.log(e.node.title.romaji);
-   *   e.voiceActors?.forEach((va) => console.log(`  VA: ${va.name.full}`));
-   * });
-   * ```
-   */
-  async getCharacter(id, include) {
-    const query = include?.voiceActors ? QUERY_CHARACTER_BY_ID_WITH_VA : QUERY_CHARACTER_BY_ID;
-    const data = await this.request(query, { id });
-    return data.Character;
-  }
-  /**
-   * Search for characters by name.
-   *
-   * @param options - Search / pagination parameters (includes optional `voiceActors`)
-   * @returns Paginated results with matching characters
-   *
-   * @example
-   * ```ts
-   * const result = await client.searchCharacters({ query: "Luffy", perPage: 5 });
-   *
-   * // With voice actors
-   * const result = await client.searchCharacters({ query: "Luffy", voiceActors: true });
-   * ```
-   */
-  async searchCharacters(options = {}) {
-    const { query: search, page = 1, perPage = 20, voiceActors, ...rest } = options;
-    const gqlQuery = voiceActors ? QUERY_CHARACTER_SEARCH_WITH_VA : QUERY_CHARACTER_SEARCH;
-    return this.pagedRequest(
-      gqlQuery,
-      { search, ...rest, page, perPage: clampPerPage(perPage) },
-      "characters"
-    );
-  }
-  /**
-   * Fetch a staff member by AniList ID.
-   *
-   * @param id - The AniList staff ID
-   * @param include - Optional include options to fetch related data (e.g. media)
-   * @returns The staff object
-   *
-   * @example
-   * ```ts
-   * const staff = await client.getStaff(95001);
-   * console.log(staff.name.full);
-   *
-   * // With media the staff worked on
-   * const staff = await client.getStaff(95001, { media: true });
-   * staff.staffMedia?.nodes.forEach((m) => console.log(m.title.romaji));
-   * ```
-   */
-  async getStaff(id, include) {
-    if (include?.media) {
-      const opts = typeof include.media === "object" ? include.media : {};
-      const perPage = opts.perPage ?? 25;
-      const data2 = await this.request(QUERY_STAFF_BY_ID_WITH_MEDIA, { id, perPage });
-      return data2.Staff;
-    }
-    const data = await this.request(QUERY_STAFF_BY_ID, { id });
-    return data.Staff;
-  }
-  /**
-   * Search for staff (voice actors, directors, etc.).
-   *
-   * @param options - Search / pagination parameters
-   * @returns Paginated results with matching staff
-   *
-   * @example
-   * ```ts
-   * const result = await client.searchStaff({ query: "Miyazaki", perPage: 5 });
-   * ```
-   */
-  async searchStaff(options = {}) {
-    const { query: search, page = 1, perPage = 20, sort } = options;
-    return this.pagedRequest(
-      QUERY_STAFF_SEARCH,
-      { search, sort, page, perPage: clampPerPage(perPage) },
-      "staff"
-    );
+    return searchMedia(this, options);
   }
-  /**
-   * Fetch a user by AniList ID.
-   *
-   * @param id - The AniList user ID
-   * @returns The user object
-   *
-   * @example
-   * ```ts
-   * const user = await client.getUser(1);
-   * console.log(user.name);
-   * ```
-   */
-  async getUser(id) {
-    const data = await this.request(QUERY_USER_BY_ID, { id });
-    return data.User;
+  /** Get currently trending anime or manga. */
+  async getTrending(type, page, perPage) {
+    return getTrending(this, type, page, perPage);
   }
-  /**
-   * Fetch a user by username.
-   *
-   * @param name - The AniList username
-   * @returns The user object
-   *
-   * @example
-   * ```ts
-   * const user = await client.getUserByName("AniList");
-   * console.log(user.statistics);
-   * ```
-   */
-  async getUserByName(name) {
-    const data = await this.request(QUERY_USER_BY_NAME, { name });
-    return data.User;
+  /** Get the most popular anime or manga. */
+  async getPopular(type, page, perPage) {
+    return getPopular(this, type, page, perPage);
   }
-  /**
-   * Execute an arbitrary GraphQL query against the AniList API.
-   * Useful for advanced use-cases not covered by the built-in methods.
-   *
-   * @param query - A valid GraphQL query string
-   * @param variables - Optional variables object
-   */
-  async raw(query, variables) {
-    return this.request(query, variables);
+  /** Get the highest-rated anime or manga. */
+  async getTopRated(type, page, perPage) {
+    return getTopRated(this, type, page, perPage);
   }
-  /**
-   * Get recently aired anime episodes.
-   *
-   * By default returns episodes that aired in the last 24 hours.
-   *
-   * @param options - Filter / pagination parameters
-   * @returns Paginated list of airing schedule entries
-   *
-   * @example
-   * ```ts
-   * // Episodes that aired in the last 48h
-   * const recent = await client.getAiredEpisodes({
-   *   airingAtGreater: Math.floor(Date.now() / 1000) - 48 * 3600,
-   * });
-   * ```
-   */
+  /** Get recently aired anime episodes. */
   async getAiredEpisodes(options = {}) {
-    const now = Math.floor(Date.now() / 1e3);
-    const variables = {
-      airingAt_greater: options.airingAtGreater ?? now - 24 * 3600,
-      airingAt_lesser: options.airingAtLesser ?? now,
-      sort: options.sort ?? ["TIME_DESC"],
-      page: options.page ?? 1,
-      perPage: clampPerPage(options.perPage ?? 20)
-    };
-    return this.pagedRequest(QUERY_AIRING_SCHEDULE, variables, "airingSchedules");
+    return getAiredEpisodes(this, options);
   }
-  /**
-   * Get manga that are currently releasing, sorted by most recently updated.
-   *
-   * This is the closest equivalent to "recently released chapters" on AniList,
-   * since the API does not expose per-chapter airing schedules for manga.
-   *
-   * @param options - Pagination parameters
-   * @returns Paginated list of currently releasing manga
-   *
-   * @example
-   * ```ts
-   * const chapters = await client.getAiredChapters({ perPage: 10 });
-   * ```
-   */
+  /** Get currently releasing manga. */
   async getAiredChapters(options = {}) {
-    return this.pagedRequest(
-      QUERY_RECENT_CHAPTERS,
-      {
-        page: options.page ?? 1,
-        perPage: clampPerPage(options.perPage ?? 20)
-      },
-      "media"
-    );
+    return getAiredChapters(this, options);
   }
-  /**
-   * Get upcoming (not yet released) anime and/or manga, sorted by popularity.
-   *
-   * @param options - Filter / pagination parameters
-   * @returns Paginated list of planned media
-   *
-   * @example
-   * ```ts
-   * import { MediaType } from "ani-client";
-   *
-   * // Most anticipated upcoming anime
-   * const planning = await client.getPlanning({ type: MediaType.ANIME, perPage: 10 });
-   * ```
-   */
+  /** Get the detailed schedule for the current week, sorted by day. */
+  async getWeeklySchedule(date) {
+    return getWeeklySchedule(this, date);
+  }
+  /** Get upcoming (not yet released) media. */
   async getPlanning(options = {}) {
-    return this.pagedRequest(
-      QUERY_PLANNING,
-      {
-        type: options.type,
-        sort: options.sort ?? ["POPULARITY_DESC"],
-        page: options.page ?? 1,
-        perPage: clampPerPage(options.perPage ?? 20)
-      },
-      "media"
-    );
+    return getPlanning(this, options);
   }
-  /**
-   * Get recommendations for a specific media.
-   *
-   * Returns other anime/manga that users have recommended based on the given media.
-   *
-   * @param mediaId - The AniList media ID
-   * @param options - Optional sort / pagination parameters
-   * @returns Paginated list of recommendations
-   *
-   * @example
-   * ```ts
-   * // Get recommendations for Cowboy Bebop
-   * const recs = await client.getRecommendations(1);
-   * recs.results.forEach((r) =>
-   *   console.log(`${r.mediaRecommendation.title.romaji} (rating: ${r.rating})`)
-   * );
-   * ```
-   */
+  /** Get recommendations for a specific media. */
   async getRecommendations(mediaId, options = {}) {
-    const variables = {
-      mediaId,
-      sort: options.sort ?? ["RATING_DESC"],
-      page: options.page ?? 1,
-      perPage: clampPerPage(options.perPage ?? 20)
-    };
-    const data = await this.request(QUERY_RECOMMENDATIONS, variables);
-    return {
-      pageInfo: data.Media.recommendations.pageInfo,
-      results: data.Media.recommendations.nodes
-    };
+    return getRecommendations(this, mediaId, options);
   }
-  /**
-   * Get anime (or manga) for a specific season and year.
-   *
-   * @param options - Season, year and optional filter / pagination parameters
-   * @returns Paginated list of media for the given season
-   *
-   * @example
-   * ```ts
-   * import { MediaSeason } from "ani-client";
-   *
-   * const winter2026 = await client.getMediaBySeason({
-   *   season: MediaSeason.WINTER,
-   *   seasonYear: 2026,
-   *   perPage: 10,
-   * });
-   * ```
-   */
+  /** Get anime (or manga) for a specific season and year. */
   async getMediaBySeason(options) {
-    return this.pagedRequest(
-      QUERY_MEDIA_BY_SEASON,
-      {
-        season: options.season,
-        seasonYear: options.seasonYear,
-        type: options.type ?? "ANIME",
-        sort: options.sort ?? ["POPULARITY_DESC"],
-        page: options.page ?? 1,
-        perPage: clampPerPage(options.perPage ?? 20)
-      },
-      "media"
-    );
+    return getMediaBySeason(this, options);
+  }
+  // ── Characters ──
+  /** Fetch a character by AniList ID. Pass `{ voiceActors: true }` to include VA data. */
+  async getCharacter(id, include) {
+    return getCharacter(this, id, include);
+  }
+  /** Search for characters by name. */
+  async searchCharacters(options = {}) {
+    return searchCharacters(this, options);
+  }
+  // ── Staff ──
+  /** Fetch a staff member by AniList ID. Pass `{ media: true }` or `{ media: { perPage } }` for media credits. */
+  async getStaff(id, include) {
+    return getStaff(this, id, include);
+  }
+  /** Search for staff (voice actors, directors, etc.). */
+  async searchStaff(options = {}) {
+    return searchStaff(this, options);
   }
+  // ── Users ──
   /**
-   * Get a user's anime or manga list.
-   *
-   * Provide either `userId` or `userName` to identify the user.
-   * Requires `type` (ANIME or MANGA). Optionally filter by list status.
-   *
-   * @param options - User identifier, media type, and optional filters
-   * @returns Paginated list of media list entries
-   *
-   * @example
-   * ```ts
-   * import { MediaType, MediaListStatus } from "ani-client";
+   * Fetch a user by AniList ID or username.
    *
-   * // Get a user's completed anime list
-   * const list = await client.getUserMediaList({
-   *   userName: "AniList",
-   *   type: MediaType.ANIME,
-   *   status: MediaListStatus.COMPLETED,
-   * });
-   * list.results.forEach((entry) =>
-   *   console.log(`${entry.media.title.romaji} — ${entry.score}/100`)
-   * );
-   * ```
+   * @param idOrName - The AniList user ID (number) or username (string)
    */
+  async getUser(idOrName) {
+    return getUser(this, idOrName);
+  }
+  /** Search for users by name. */
+  async searchUsers(options = {}) {
+    return searchUsers(this, options);
+  }
+  /** Get a user's anime or manga list. */
   async getUserMediaList(options) {
-    if (!options.userId && !options.userName) {
-      throw new Error("Either userId or userName must be provided");
-    }
-    return this.pagedRequest(
-      QUERY_USER_MEDIA_LIST,
-      {
-        userId: options.userId,
-        userName: options.userName,
-        type: options.type,
-        status: options.status,
-        sort: options.sort,
-        page: options.page ?? 1,
-        perPage: clampPerPage(options.perPage ?? 20)
-      },
-      "mediaList"
-    );
+    return getUserMediaList(this, options);
   }
-  /**
-   * Fetch a studio by its AniList ID.
-   *
-   * Returns studio details along with its most popular productions.
-   *
-   * @param id - The AniList studio ID
-   */
+  // ── Studios ──
+  /** Fetch a studio by its AniList ID. */
   async getStudio(id) {
-    const data = await this.request(QUERY_STUDIO_BY_ID, { id });
-    return data.Studio;
+    return getStudio(this, id);
   }
-  /**
-   * Search for studios by name.
-   *
-   * @param options - Search / pagination parameters
-   * @returns Paginated list of studios
-   *
-   * @example
-   * ```ts
-   * const studios = await client.searchStudios({ query: "MAPPA" });
-   * ```
-   */
+  /** Search for studios by name. */
   async searchStudios(options = {}) {
-    return this.pagedRequest(
-      QUERY_STUDIO_SEARCH,
-      {
-        search: options.query,
-        page: options.page ?? 1,
-        perPage: clampPerPage(options.perPage ?? 20)
-      },
-      "studios"
-    );
+    return searchStudios(this, options);
   }
-  /**
-   * Get all available genres on AniList.
-   *
-   * @returns Array of genre strings (e.g. "Action", "Adventure", ...)
-   */
+  // ── Metadata ──
+  // ── Threads ──
+  /** Fetch a forum thread by its AniList ID. */
+  async getThread(id) {
+    return getThread(this, id);
+  }
+  /** Get recent forum threads, optionally filtered by search, media, or category. */
+  async getRecentThreads(options = {}) {
+    return getRecentThreads(this, options);
+  }
+  /** Get all available genres on AniList. */
   async getGenres() {
     const data = await this.request(QUERY_GENRES);
     return data.GenreCollection;
   }
-  /**
-   * Get all available media tags on AniList.
-   *
-   * @returns Array of tag objects with id, name, description, category, isAdult
-   */
+  /** Get all available media tags on AniList. */
   async getTags() {
     const data = await this.request(QUERY_TAGS);
     return data.MediaTagCollection;
   }
+  // ── Raw query ──
+  /** Execute an arbitrary GraphQL query against the AniList API. */
+  async raw(query, variables) {
+    return this.request(query, variables ?? {});
+  }
+  // ── Pagination ──
   /**
-   * Auto-paginating async iterator.
-   *
-   * Wraps any paginated method and yields individual items across all pages.
-   * Stops when `hasNextPage` is `false` or `maxPages` is reached.
+   * Auto-paginating async iterator. Yields individual items across all pages.
    *
    * @param fetchPage - A function that takes a page number and returns a `PagedResult<T>`
    * @param maxPages - Maximum number of pages to fetch (default: Infinity)
-   * @returns An async iterable iterator of individual items
-   *
-   * @example
-   * ```ts
-   * // Iterate over all search results
-   * for await (const anime of client.paginate((page) =>
-   *   client.searchMedia({ query: "Naruto", page, perPage: 10 })
-   * )) {
-   *   console.log(anime.title.romaji);
-   * }
-   *
-   * // Limit to 3 pages
-   * for await (const anime of client.paginate(
-   *   (page) => client.getTrending(MediaType.ANIME, page, 20),
-   *   3,
-   * )) {
-   *   console.log(anime.title.romaji);
-   * }
-   * ```
    */
   async *paginate(fetchPage, maxPages = Number.POSITIVE_INFINITY) {
     let page = 1;
@@ -1481,35 +1576,19 @@ var AniListClient = class {
     }
   }
   // ── Batch queries ──
-  /**
-   * Fetch multiple media entries in a single API request.
-   * Uses GraphQL aliases to batch up to 50 IDs per call.
-   *
-   * @param ids - Array of AniList media IDs
-   * @returns Array of media objects (same order as input IDs)
-   */
+  /** Fetch multiple media entries in a single API request. */
   async getMediaBatch(ids) {
     if (ids.length === 0) return [];
     if (ids.length === 1) return [await this.getMedia(ids[0])];
     return this.executeBatch(ids, buildBatchMediaQuery, "m");
   }
-  /**
-   * Fetch multiple characters in a single API request.
-   *
-   * @param ids - Array of AniList character IDs
-   * @returns Array of character objects (same order as input IDs)
-   */
+  /** Fetch multiple characters in a single API request. */
   async getCharacterBatch(ids) {
     if (ids.length === 0) return [];
     if (ids.length === 1) return [await this.getCharacter(ids[0])];
     return this.executeBatch(ids, buildBatchCharacterQuery, "c");
   }
-  /**
-   * Fetch multiple staff members in a single API request.
-   *
-   * @param ids - Array of AniList staff IDs
-   * @returns Array of staff objects (same order as input IDs)
-   */
+  /** Fetch multiple staff members in a single API request. */
   async getStaffBatch(ids) {
     if (ids.length === 0) return [];
     if (ids.length === 1) return [await this.getStaff(ids[0])];
@@ -1527,25 +1606,15 @@ var AniListClient = class {
     return chunkResults.flat();
   }
   // ── Cache management ──
-  /**
-   * Clear the entire response cache.
-   */
+  /** Clear the entire response cache. */
   async clearCache() {
     await this.cacheAdapter.clear();
   }
-  /**
-   * Number of entries currently in the cache.
-   * For async adapters like Redis, this may return a Promise.
-   */
+  /** Number of entries currently in the cache. */
   get cacheSize() {
     return this.cacheAdapter.size;
   }
-  /**
-   * Remove cache entries whose key matches the given pattern.
-   *
-   * @param pattern — A string (converted to RegExp) or RegExp
-   * @returns Number of entries removed
-   */
+  /** Remove cache entries whose key matches the given pattern. */
   async invalidateCache(pattern) {
     if (this.cacheAdapter.invalidate) {
       return this.cacheAdapter.invalidate(pattern);
@@ -1561,6 +1630,11 @@ var AniListClient = class {
     }
     return count;
   }
+  /** Clean up resources held by the client. */
+  async destroy() {
+    await this.cacheAdapter.clear();
+    this.inFlight.clear();
+  }
 };
 
 // src/cache/redis.ts
@@ -1657,6 +1731,7 @@ exports.MediaListStatus = MediaListStatus;
 exports.MediaRelationType = MediaRelationType;
 exports.MediaSeason = MediaSeason;
 exports.MediaSort = MediaSort;
+exports.MediaSource = MediaSource;
 exports.MediaStatus = MediaStatus;
 exports.MediaType = MediaType;
 exports.MemoryCache = MemoryCache;
@@ -1664,5 +1739,8 @@ exports.RateLimiter = RateLimiter;
 exports.RecommendationSort = RecommendationSort;
 exports.RedisCache = RedisCache;
 exports.StaffSort = StaffSort;
+exports.ThreadSort = ThreadSort;
+exports.UserSort = UserSort;
+exports.parseAniListMarkdown = parseAniListMarkdown;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map