@francofantomius/jellyfin 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2247 @@
+'use strict';
+
+// src/errors.ts
+var JellyfinError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JellyfinError";
+  }
+};
+var JellyfinApiError = class extends JellyfinError {
+  status;
+  endpoint;
+  constructor(message, status, endpoint) {
+    super(message);
+    this.name = "JellyfinApiError";
+    this.status = status;
+    this.endpoint = endpoint;
+  }
+};
+var JellyfinAuthError = class extends JellyfinApiError {
+  constructor(message = "Unauthorized. Please check your Jellyfin credentials.", status = 401, endpoint) {
+    super(message, status, endpoint);
+    this.name = "JellyfinAuthError";
+  }
+};
+
+// src/http.ts
+function cleanUrl(url) {
+  if (!url) return "";
+  let cleaned = url.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//i.test(cleaned)) {
+    cleaned = "https://" + cleaned;
+  }
+  return cleaned;
+}
+function buildAuthHeader(clientInfo, token) {
+  const tokenPart = token ? `, Token="${token}"` : "";
+  return `MediaBrowser Client="${clientInfo.name}", Device="${clientInfo.device}", DeviceId="${clientInfo.deviceId}", Version="${clientInfo.version}"${tokenPart}`;
+}
+var HttpTransport = class {
+  serverUrl = "";
+  token = "";
+  clientInfo;
+  fetchFn;
+  onUnauthorized;
+  constructor(options) {
+    this.serverUrl = options.serverUrl ? cleanUrl(options.serverUrl) : "";
+    this.token = options.token || "";
+    this.clientInfo = options.clientInfo;
+    this.fetchFn = options.fetch || (globalThis.fetch ? globalThis.fetch.bind(globalThis) : fetch);
+    this.onUnauthorized = options.onUnauthorized;
+  }
+  setServerUrl(url) {
+    this.serverUrl = cleanUrl(url);
+  }
+  getServerUrl() {
+    return this.serverUrl;
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  getToken() {
+    return this.token;
+  }
+  setClientInfo(info) {
+    this.clientInfo = { ...this.clientInfo, ...info };
+  }
+  getClientInfo() {
+    return this.clientInfo;
+  }
+  setOnUnauthorized(handler) {
+    this.onUnauthorized = handler;
+  }
+  getAuthHeader() {
+    return buildAuthHeader(this.clientInfo, this.token);
+  }
+  async requestRaw(endpoint, options = {}) {
+    if (!this.serverUrl) {
+      throw new JellyfinError("Jellyfin server URL is not configured.");
+    }
+    const { method = "GET", params = {}, body = null, contentType, headers: customHeaders = {} } = options;
+    const url = new URL(`${this.serverUrl}${endpoint.startsWith("/") ? "" : "/"}${endpoint}`);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+    const authHeader = this.getAuthHeader();
+    const headers = {
+      "X-Emby-Authorization": authHeader,
+      "Authorization": authHeader,
+      ...customHeaders
+    };
+    let serializedBody;
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+      serializedBody = typeof body === "string" ? body : JSON.stringify(body);
+    } else if (body !== null && body !== void 0) {
+      if (typeof body === "string") {
+        headers["Content-Type"] = "application/json";
+        serializedBody = body;
+      } else {
+        headers["Content-Type"] = "application/json";
+        serializedBody = JSON.stringify(body);
+      }
+    }
+    let response;
+    try {
+      response = await this.fetchFn(url.toString(), {
+        method,
+        headers,
+        body: serializedBody
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      throw new JellyfinError(`Network request failed (${endpoint}): ${errorMsg}`);
+    }
+    if (response.status === 401 || response.status === 403) {
+      if (response.status === 401 && this.onUnauthorized) {
+        try {
+          this.onUnauthorized();
+        } catch {
+        }
+      }
+      throw new JellyfinAuthError(`Unauthorized (HTTP ${response.status}) on ${endpoint}`, response.status, endpoint);
+    }
+    if (!response.ok) {
+      throw new JellyfinApiError(`Jellyfin API request failed (${endpoint}): ${response.statusText}`, response.status, endpoint);
+    }
+    return response;
+  }
+  async request(endpoint, options = {}) {
+    const response = await this.requestRaw(endpoint, {
+      ...options,
+      headers: {
+        Accept: "application/json",
+        ...options.headers || {}
+      }
+    });
+    const contentTypeHeader = response.headers.get("Content-Type") || "";
+    if (contentTypeHeader.includes("application/json")) {
+      return await response.json();
+    }
+    return null;
+  }
+  async requestText(endpoint, options = {}) {
+    const response = await this.requestRaw(endpoint, {
+      ...options,
+      headers: {
+        Accept: "text/vtt, text/plain, */*",
+        ...options.headers || {}
+      }
+    });
+    return await response.text();
+  }
+  async requestBlob(endpoint, options = {}) {
+    const response = await this.requestRaw(endpoint, options);
+    return await response.blob();
+  }
+};
+
+// src/auth.ts
+var AuthModule = class {
+  http;
+  currentUser = null;
+  currentUserId = "";
+  currentUsername = "";
+  constructor(http, userId = "") {
+    this.http = http;
+    this.currentUserId = userId;
+  }
+  getUserId() {
+    return this.currentUserId;
+  }
+  setUserId(id) {
+    this.currentUserId = id;
+  }
+  getUsername() {
+    return this.currentUsername || this.currentUser?.Name || "";
+  }
+  getCurrentUser() {
+    return this.currentUser;
+  }
+  setCurrentUser(user) {
+    this.currentUser = user;
+    if (user?.Id) {
+      this.currentUserId = user.Id;
+    }
+    if (user?.Name) {
+      this.currentUsername = user.Name;
+    }
+  }
+  /**
+   * Authenticate with the Jellyfin server using username and password.
+   */
+  async authenticateByName(username, password = "") {
+    if (!username || !username.trim()) {
+      throw new JellyfinError("Username is required for authentication.");
+    }
+    const result = await this.http.request("/Users/AuthenticateByName", {
+      method: "POST",
+      body: {
+        Username: username.trim(),
+        Pw: password || ""
+      }
+    });
+    if (!result || !result.AccessToken || !result.User?.Id) {
+      throw new JellyfinAuthError("Invalid response received from Jellyfin authentication endpoint.");
+    }
+    this.http.setToken(result.AccessToken);
+    this.setCurrentUser(result.User);
+    this.currentUsername = result.User.Name;
+    return result;
+  }
+  /**
+   * Report client capabilities to the Jellyfin server.
+   */
+  async reportCapabilities(capabilities) {
+    const payload = {
+      PlayableMediaTypes: ["Audio", "Video"],
+      SupportedCommands: [
+        "Play",
+        "PlayState",
+        "PlayNext",
+        "SetRepeatMode",
+        "SetShuffleQueue"
+      ],
+      SupportsMediaControl: true,
+      SupportsSync: false,
+      SupportsPersistentIdentifier: true,
+      MessageFormat: "Json",
+      ...capabilities
+    };
+    try {
+      await this.http.request("/Sessions/Capabilities/Full", {
+        method: "POST",
+        body: payload
+      });
+    } catch {
+      try {
+        await this.http.request("/Sessions/Capabilities", {
+          method: "POST",
+          body: payload
+        });
+      } catch (fallbackErr) {
+        console.warn("[Jellyfin SDK] Failed to report client capabilities:", fallbackErr);
+      }
+    }
+  }
+  /**
+   * Build the user profile avatar image URL.
+   */
+  getUserImageUrl(userId, tag) {
+    const uid = userId || this.currentUserId;
+    const serverUrl = this.http.getServerUrl();
+    if (!serverUrl || !uid) return "";
+    const tagToUse = tag || this.currentUser?.PrimaryImageTag || this.currentUser?.ImageTags?.Primary || "";
+    const tagParam = tagToUse ? `?tag=${tagToUse}` : "";
+    return `${serverUrl}/Users/${uid}/Images/Primary${tagParam}`;
+  }
+  /**
+   * Clear active user credentials and token.
+   */
+  logout() {
+    this.http.setToken("");
+    this.currentUserId = "";
+    this.currentUsername = "";
+    this.currentUser = null;
+  }
+};
+
+// src/system.ts
+function parseSemVer(version) {
+  if (!version) return null;
+  const match = version.trim().match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: match[3] ? parseInt(match[3], 10) : 0
+  };
+}
+function isVersionAtLeast(currentVersion, targetVersion) {
+  const current = parseSemVer(currentVersion);
+  const target = parseSemVer(targetVersion);
+  if (!current || !target) return false;
+  if (current.major !== target.major) {
+    return current.major > target.major;
+  }
+  if (current.minor !== target.minor) {
+    return current.minor > target.minor;
+  }
+  return current.patch >= target.patch;
+}
+function isV12OrHigher(version) {
+  if (!version) return false;
+  const parsed = parseSemVer(version);
+  if (!parsed) return false;
+  return parsed.major >= 12;
+}
+var SystemModule = class {
+  http;
+  serverVersion = null;
+  targetVersion = "auto";
+  constructor(http, options) {
+    this.http = http;
+    if (options?.serverVersion) {
+      this.serverVersion = options.serverVersion;
+    }
+    if (options?.targetVersion) {
+      this.targetVersion = options.targetVersion;
+    }
+  }
+  /**
+   * Get public system info without requiring authentication.
+   */
+  async getPublicInfo() {
+    const info = await this.http.request("/System/Info/Public");
+    if (info?.Version) {
+      this.serverVersion = info.Version;
+    }
+    return info;
+  }
+  /**
+   * Get full system info (requires authentication).
+   */
+  async getInfo() {
+    const info = await this.http.request("/System/Info");
+    if (info?.Version) {
+      this.serverVersion = info.Version;
+    }
+    return info;
+  }
+  /**
+   * Get the cached or explicitly configured server version string.
+   */
+  getVersion() {
+    return this.serverVersion;
+  }
+  /**
+   * Manually set or override the server version.
+   */
+  setVersion(version) {
+    this.serverVersion = version;
+  }
+  /**
+   * Get the configured target compatibility mode.
+   */
+  getTargetVersion() {
+    return this.targetVersion;
+  }
+  /**
+   * Set target compatibility mode.
+   */
+  setTargetVersion(target) {
+    this.targetVersion = target;
+  }
+  /**
+   * Detects and caches the server version by calling /System/Info/Public.
+   */
+  async detectVersion() {
+    try {
+      const info = await this.getPublicInfo();
+      return info?.Version || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Checks whether the current server is Jellyfin 12 or higher.
+   * If targetVersion is explicitly set to '12' or '10', that preference is honored.
+   * If 'auto', resolves against known version or attempts detection.
+   */
+  async isV12() {
+    if (this.targetVersion === "12") return true;
+    if (this.targetVersion === "10") return false;
+    if (!this.serverVersion) {
+      await this.detectVersion();
+    }
+    if (this.serverVersion) {
+      return isV12OrHigher(this.serverVersion);
+    }
+    return true;
+  }
+  /**
+   * Synchronously checks if the server is known to be v12+ based on cached version or target setting.
+   * Defaults to true (modern behavior) if unknown.
+   */
+  isV12Sync() {
+    if (this.targetVersion === "12") return true;
+    if (this.targetVersion === "10") return false;
+    if (this.serverVersion) {
+      return isV12OrHigher(this.serverVersion);
+    }
+    return true;
+  }
+};
+
+// src/library.ts
+var COMMON_ITEM_FIELDS = "PrimaryImageAspectRatio,PrimaryImageTag,ImageTags,BackdropImageTags,AlbumPrimaryImageTag,AlbumId,AudioInfo,MediaSources,Chapters,HasLyrics,Overview,Genres,Studios,ProductionYear,OfficialRating,CommunityRating,CriticRating,PremiereDate,RunTimeTicks,IndexNumber,ParentIndexNumber,SeriesName,SeriesId,SeasonId,SeasonName,UserData";
+var LibraryModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  requireUserId() {
+    const userId = this.getUserId();
+    if (!userId) {
+      throw new JellyfinError("User ID is required for library requests. Please authenticate or provide a userId.");
+    }
+    return userId;
+  }
+  /**
+   * Get list of music library views (folders) for the current user.
+   */
+  async getMusicLibraries() {
+    const userId = this.requireUserId();
+    const data = await this.http.request(`/Users/${userId}/Views`);
+    return (data.Items || []).filter((item) => item.CollectionType === "music");
+  }
+  /**
+   * Get list of video library views (movies, tv shows, home videos) for the current user.
+   */
+  async getVideoLibraries() {
+    const userId = this.requireUserId();
+    const data = await this.http.request(`/Users/${userId}/Views`);
+    const videoTypes = /* @__PURE__ */ new Set(["movies", "tvshows", "homevideos", "videos", "musicvideos"]);
+    return (data.Items || []).filter(
+      (item) => typeof item.CollectionType === "string" && videoTypes.has(item.CollectionType)
+    );
+  }
+  /**
+   * Get music albums.
+   */
+  async getAlbums(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 50,
+      startIndex = 0,
+      parentId,
+      artistId,
+      sortBy = "SortName",
+      sortOrder = "Ascending"
+    } = options;
+    const params = {
+      IncludeItemTypes: "MusicAlbum",
+      Recursive: true,
+      Limit: limit,
+      StartIndex: startIndex,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: "PrimaryImageAspectRatio,PrimaryImageTag,ImageTags,BasicSyncInfo,AlbumArtists,ArtistItems,DateCreated,DateLastMediaAdded,UserData"
+    };
+    if (parentId) params.ParentId = parentId;
+    if (artistId) params.ArtistIds = artistId;
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * Get music artists.
+   */
+  async getArtists(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 50,
+      startIndex = 0,
+      sortBy = "SortName",
+      sortOrder = "Ascending"
+    } = options;
+    return await this.http.request("/Artists", {
+      params: {
+        UserId: userId,
+        Limit: limit,
+        StartIndex: startIndex,
+        SortBy: sortBy,
+        SortOrder: sortOrder,
+        Fields: "PrimaryImageTag,ImageTags,DateCreated,UserData"
+      }
+    });
+  }
+  /**
+   * Get audio songs/tracks.
+   */
+  async getSongs(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 100,
+      startIndex = 0,
+      albumId,
+      artistId,
+      isFavorite,
+      sortBy = "ParentIndexNumber,IndexNumber,SortName",
+      sortOrder = "Ascending"
+    } = options;
+    const params = {
+      IncludeItemTypes: "Audio",
+      Recursive: true,
+      Limit: limit,
+      StartIndex: startIndex,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: COMMON_ITEM_FIELDS
+    };
+    if (albumId) params.ParentId = albumId;
+    if (artistId) params.ArtistIds = artistId;
+    if (isFavorite) params.Filters = "IsFavorite";
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * Get favorite songs/tracks for the current user.
+   */
+  async getFavoriteSongs(options = {}) {
+    return await this.getSongs({
+      ...options,
+      isFavorite: true,
+      limit: options.limit || 1e3,
+      sortBy: options.sortBy || "SortName"
+    });
+  }
+  /**
+   * Get movies for the current user.
+   */
+  async getMovies(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 50,
+      startIndex = 0,
+      parentId,
+      isFavorite,
+      sortBy = "SortName",
+      sortOrder = "Ascending",
+      genres,
+      years,
+      searchTerm
+    } = options;
+    const params = {
+      IncludeItemTypes: "Movie",
+      Recursive: true,
+      Limit: limit,
+      StartIndex: startIndex,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: COMMON_ITEM_FIELDS
+    };
+    if (parentId) params.ParentId = parentId;
+    if (isFavorite) params.Filters = "IsFavorite";
+    if (genres && genres.length > 0) params.Genres = genres.join("|");
+    if (years && years.length > 0) params.Years = years.join(",");
+    if (searchTerm) params.SearchTerm = searchTerm;
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * Get TV series for the current user.
+   */
+  async getSeries(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 50,
+      startIndex = 0,
+      parentId,
+      isFavorite,
+      sortBy = "SortName",
+      sortOrder = "Ascending",
+      genres,
+      years,
+      searchTerm
+    } = options;
+    const params = {
+      IncludeItemTypes: "Series",
+      Recursive: true,
+      Limit: limit,
+      StartIndex: startIndex,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: COMMON_ITEM_FIELDS
+    };
+    if (parentId) params.ParentId = parentId;
+    if (isFavorite) params.Filters = "IsFavorite";
+    if (genres && genres.length > 0) params.Genres = genres.join("|");
+    if (years && years.length > 0) params.Years = years.join(",");
+    if (searchTerm) params.SearchTerm = searchTerm;
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * Get seasons for a given TV series.
+   */
+  async getSeasons(seriesId, options = {}) {
+    const userId = options.userId || this.requireUserId();
+    const params = {
+      UserId: userId,
+      Fields: options.fields || COMMON_ITEM_FIELDS
+    };
+    if (options.isSpecialSeason !== void 0) {
+      params.IsSpecialSeason = options.isSpecialSeason;
+    }
+    return await this.http.request(`/Shows/${seriesId}/Seasons`, { params });
+  }
+  /**
+   * Get episodes for a TV series or specific season.
+   */
+  async getEpisodes(seriesId, seasonId, options = {}) {
+    const userId = this.requireUserId();
+    const {
+      seasonNumber,
+      startIndex = 0,
+      limit = 100,
+      isMissing,
+      sortBy = "IndexNumber,SortName",
+      sortOrder = "Ascending"
+    } = options;
+    if (seriesId) {
+      const params2 = {
+        UserId: userId,
+        StartIndex: startIndex,
+        Limit: limit,
+        SortBy: sortBy,
+        SortOrder: sortOrder,
+        Fields: COMMON_ITEM_FIELDS
+      };
+      if (seasonId) params2.SeasonId = seasonId;
+      if (seasonNumber !== void 0) params2.Season = seasonNumber;
+      if (isMissing !== void 0) params2.IsMissing = isMissing;
+      return await this.http.request(`/Shows/${seriesId}/Episodes`, { params: params2 });
+    }
+    const params = {
+      IncludeItemTypes: "Episode",
+      Recursive: true,
+      StartIndex: startIndex,
+      Limit: limit,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: COMMON_ITEM_FIELDS
+    };
+    if (seasonId) params.ParentId = seasonId;
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * General query for video items (movies, episodes, videos).
+   */
+  async getVideos(options = {}) {
+    const userId = this.requireUserId();
+    const {
+      limit = 50,
+      startIndex = 0,
+      parentId,
+      includeItemTypes = "Movie,Episode,Video",
+      sortBy = "SortName",
+      sortOrder = "Ascending"
+    } = options;
+    const params = {
+      IncludeItemTypes: includeItemTypes,
+      Recursive: true,
+      Limit: limit,
+      StartIndex: startIndex,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      Fields: COMMON_ITEM_FIELDS
+    };
+    if (parentId) params.ParentId = parentId;
+    return await this.http.request(`/Users/${userId}/Items`, { params });
+  }
+  /**
+   * Request media playback information for an item (sources, streams, play session).
+   */
+  async getPlaybackInfo(itemId, options = {}) {
+    if (!itemId) {
+      throw new JellyfinError("itemId is required for getPlaybackInfo");
+    }
+    const userId = options.userId || this.requireUserId();
+    const payload = {
+      UserId: userId
+    };
+    if (options.startTimeTicks !== void 0) payload.StartTimeTicks = options.startTimeTicks;
+    if (options.audioStreamIndex !== void 0) payload.AudioStreamIndex = options.audioStreamIndex;
+    if (options.subtitleStreamIndex !== void 0) payload.SubtitleStreamIndex = options.subtitleStreamIndex;
+    if (options.maxStreamingBitrate !== void 0) payload.MaxStreamingBitrate = options.maxStreamingBitrate;
+    if (options.mediaSourceId !== void 0) payload.MediaSourceId = options.mediaSourceId;
+    if (options.deviceProfile !== void 0) payload.DeviceProfile = options.deviceProfile;
+    if (options.autoOpenLiveStream !== void 0) payload.AutoOpenLiveStream = options.autoOpenLiveStream;
+    return await this.http.request(`/Items/${itemId}/PlaybackInfo`, {
+      method: "POST",
+      body: payload
+    });
+  }
+  /**
+   * Get single item details by its Jellyfin ID.
+   */
+  async getItem(itemId) {
+    if (!itemId) return null;
+    const userId = this.requireUserId();
+    return await this.http.request(`/Users/${userId}/Items/${itemId}`, {
+      params: {
+        Fields: COMMON_ITEM_FIELDS
+      }
+    });
+  }
+  /**
+   * Search Jellyfin library for songs, albums, artists, playlists, movies, or series.
+   */
+  async search(query, options = {}) {
+    if (!query || !query.trim()) {
+      return { Items: [], TotalRecordCount: 0 };
+    }
+    const userId = this.requireUserId();
+    const {
+      limit = 30,
+      startIndex = 0,
+      includeItemTypes = "Audio,MusicAlbum,MusicArtist,Playlist,Movie,Series,Episode"
+    } = options;
+    return await this.http.request(`/Users/${userId}/Items`, {
+      params: {
+        SearchTerm: query.trim(),
+        IncludeItemTypes: includeItemTypes,
+        Limit: limit,
+        StartIndex: startIndex,
+        Recursive: true,
+        Fields: COMMON_ITEM_FIELDS
+      }
+    });
+  }
+};
+
+// src/playlists.ts
+var PlaylistsModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  requireUserId() {
+    const userId = this.getUserId();
+    if (!userId) {
+      throw new JellyfinError("User ID is required for playlist operations.");
+    }
+    return userId;
+  }
+  /**
+   * Get all playlists for the current user.
+   */
+  async getPlaylists() {
+    const userId = this.requireUserId();
+    return await this.http.request(`/Users/${userId}/Items`, {
+      params: {
+        IncludeItemTypes: "Playlist",
+        Recursive: true,
+        Fields: "PrimaryImageTag,ImageTags,DateCreated,DateLastMediaAdded,UserData"
+      }
+    });
+  }
+  /**
+   * Get items belonging to a specific playlist.
+   */
+  async getPlaylistItems(playlistId) {
+    if (!playlistId) {
+      throw new JellyfinError("Playlist ID is required.");
+    }
+    const userId = this.requireUserId();
+    return await this.http.request(`/Playlists/${playlistId}/Items`, {
+      params: {
+        UserId: userId,
+        Fields: "PrimaryImageAspectRatio,PrimaryImageTag,ImageTags,AlbumPrimaryImageTag,AlbumId,AudioInfo,MediaSources,HasLyrics,UserData"
+      }
+    });
+  }
+  /**
+   * Create a new playlist.
+   * Jellyfin 12 requires a JSON request body with CreatePlaylistDto.
+   * Falls back to legacy query parameters if server returns 400/415.
+   */
+  async createPlaylist(options) {
+    const userId = options.userId || this.requireUserId();
+    const { name, isPublic = false, trackIds = [], mediaType = "Audio" } = options;
+    if (!name || !name.trim()) {
+      throw new JellyfinError("Playlist name is required.");
+    }
+    const idsArray = Array.isArray(trackIds) ? trackIds : [trackIds].filter(Boolean);
+    let playlistId;
+    try {
+      const resData = await this.http.request("/Playlists", {
+        method: "POST",
+        body: {
+          Name: name.trim(),
+          Ids: idsArray,
+          UserId: userId,
+          MediaType: mediaType
+        }
+      });
+      playlistId = resData?.Id;
+    } catch (err) {
+      if (err instanceof JellyfinApiError && (err.status === 400 || err.status === 415)) {
+        const idsStr = idsArray.join(",");
+        const resData = await this.http.request("/Playlists", {
+          method: "POST",
+          params: {
+            Name: name.trim(),
+            UserId: userId,
+            MediaType: mediaType,
+            ...idsStr ? { Ids: idsStr } : {}
+          }
+        });
+        playlistId = resData?.Id;
+      } else {
+        throw err;
+      }
+    }
+    if (playlistId && isPublic) {
+      try {
+        await this.http.request(`/Playlists/${playlistId}/Users/${userId}`, {
+          method: "POST",
+          body: { UserId: userId, CanEdit: true }
+        });
+      } catch {
+        try {
+          await this.http.request(`/Playlists/${playlistId}`, {
+            method: "POST",
+            body: { IsPublic: true }
+          });
+        } catch (err) {
+          console.warn("[Jellyfin SDK] Failed to update public status for playlist:", err);
+        }
+      }
+    }
+    return playlistId || "";
+  }
+  /**
+   * Update playlist metadata (e.g. name).
+   * Jellyfin 12 removed POST /Playlists/{id}; item updates use POST /Items/{id},
+   * which is also supported across older Jellyfin versions.
+   */
+  async updatePlaylist(playlistId, options) {
+    if (!playlistId) {
+      throw new JellyfinError("Playlist ID is required.");
+    }
+    const body = { Id: playlistId };
+    if (options.name) body.Name = options.name;
+    try {
+      await this.http.request(`/Items/${playlistId}`, {
+        method: "POST",
+        body
+      });
+    } catch (err) {
+      await this.http.request(`/Playlists/${playlistId}`, {
+        method: "POST",
+        body: options.name ? { Name: options.name } : {}
+      });
+    }
+  }
+  /**
+   * Upload custom cover image for a playlist.
+   */
+  async uploadPlaylistImage(playlistId, base64ImageString, mimeType = "image/jpeg") {
+    if (!playlistId || !base64ImageString) {
+      throw new JellyfinError("Playlist ID and image data are required.");
+    }
+    const base64Data = base64ImageString.includes(",") ? base64ImageString.split(",")[1] : base64ImageString;
+    await this.http.request(`/Items/${playlistId}/Images/Primary`, {
+      method: "POST",
+      contentType: mimeType,
+      body: base64Data
+    });
+  }
+  /**
+   * Delete a playlist.
+   */
+  async deletePlaylist(playlistId) {
+    if (!playlistId) {
+      throw new JellyfinError("Playlist ID is required.");
+    }
+    await this.http.request(`/Items/${playlistId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Add tracks to an existing playlist.
+   */
+  async addTracks(playlistId, trackIds) {
+    if (!playlistId || !trackIds) return;
+    const userId = this.requireUserId();
+    const idsStr = Array.isArray(trackIds) ? trackIds.join(",") : trackIds;
+    if (!idsStr) return;
+    await this.http.request(`/Playlists/${playlistId}/Items`, {
+      method: "POST",
+      params: {
+        Ids: idsStr,
+        UserId: userId
+      }
+    });
+  }
+  /**
+   * Remove a track from a playlist by playlist entry ID or track ID.
+   */
+  async removeTrack(playlistId, entryIdOrTrackId) {
+    if (!playlistId || !entryIdOrTrackId) return;
+    try {
+      await this.http.request(`/Playlists/${playlistId}/Items`, {
+        method: "DELETE",
+        params: { EntryIds: entryIdOrTrackId }
+      });
+    } catch {
+      await this.http.request(`/Playlists/${playlistId}/Items`, {
+        method: "DELETE",
+        params: { ItemIds: entryIdOrTrackId }
+      });
+    }
+  }
+  /**
+   * Remove a specific playlist item by its unique entry ID (PlaylistItemId).
+   * Especially recommended on Jellyfin 12+ when playlists contain duplicate tracks.
+   */
+  async removePlaylistItem(playlistId, playlistItemId) {
+    return this.removeTrack(playlistId, playlistItemId);
+  }
+};
+
+// src/playback.ts
+var PlaybackModule = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Report to the Jellyfin server that playback has started for an item.
+   */
+  async reportStart(itemId, positionTicks = 0) {
+    if (!itemId || !this.http.getToken()) return;
+    try {
+      await this.http.request("/Sessions/Playing", {
+        method: "POST",
+        body: {
+          ItemId: itemId,
+          PositionTicks: positionTicks,
+          CanSeek: true,
+          IsPaused: false
+        }
+      });
+    } catch (e) {
+      console.warn("[Jellyfin SDK] Start playback report error:", e);
+    }
+  }
+  /**
+   * Report current playback progress to the Jellyfin server.
+   */
+  async reportProgress(itemId, positionTicks = 0, isPaused = false) {
+    if (!itemId || !this.http.getToken()) return;
+    try {
+      await this.http.request("/Sessions/Playing/Progress", {
+        method: "POST",
+        body: {
+          ItemId: itemId,
+          PositionTicks: positionTicks,
+          CanSeek: true,
+          IsPaused: isPaused
+        }
+      });
+    } catch (e) {
+      console.warn("[Jellyfin SDK] Progress playback report error:", e);
+    }
+  }
+  /**
+   * Report that playback has stopped for an item.
+   */
+  async reportStopped(itemId, positionTicks = 0) {
+    if (!itemId || !this.http.getToken()) return;
+    try {
+      await this.http.request("/Sessions/Playing/Stopped", {
+        method: "POST",
+        body: {
+          ItemId: itemId,
+          PositionTicks: positionTicks
+        }
+      });
+    } catch (e) {
+      console.warn("[Jellyfin SDK] Stop playback report error:", e);
+    }
+  }
+};
+
+// src/quality.ts
+var VIDEO_QUALITY_PRESETS = {
+  direct: { key: "direct", label: "Original (Direct)" },
+  auto: { key: "auto", label: "Auto" },
+  "4k": { key: "4k", label: "4K Ultra HD (60 Mbps)", bitrate: 6e7, maxWidth: 3840, maxHeight: 2160 },
+  "1080p-high": { key: "1080p-high", label: "1080p High (20 Mbps)", bitrate: 2e7, maxWidth: 1920, maxHeight: 1080 },
+  "1080p": { key: "1080p", label: "1080p (10 Mbps)", bitrate: 1e7, maxWidth: 1920, maxHeight: 1080 },
+  "720p-high": { key: "720p-high", label: "720p High (6 Mbps)", bitrate: 6e6, maxWidth: 1280, maxHeight: 720 },
+  "720p": { key: "720p", label: "720p (4 Mbps)", bitrate: 4e6, maxWidth: 1280, maxHeight: 720 },
+  "480p": { key: "480p", label: "480p (2 Mbps)", bitrate: 2e6, maxWidth: 854, maxHeight: 480 },
+  "360p": { key: "360p", label: "360p (1 Mbps)", bitrate: 1e6, maxWidth: 640, maxHeight: 360 },
+  "240p": { key: "240p", label: "240p (420 kbps)", bitrate: 42e4, maxWidth: 426, maxHeight: 240 }
+};
+var AUDIO_QUALITY_PRESETS = {
+  direct: { key: "direct", label: "Original (Direct)" },
+  "320k": { key: "320k", label: "320 kbps", bitrate: 32e4 },
+  "256k": { key: "256k", label: "256 kbps", bitrate: 256e3 },
+  "192k": { key: "192k", label: "192 kbps", bitrate: 192e3 },
+  "128k": { key: "128k", label: "128 kbps", bitrate: 128e3 },
+  "64k": { key: "64k", label: "64 kbps", bitrate: 64e3 }
+};
+function getVideoQualityList() {
+  return Object.values(VIDEO_QUALITY_PRESETS);
+}
+function getAudioQualityList() {
+  return Object.values(AUDIO_QUALITY_PRESETS);
+}
+function resolveVideoQuality(quality) {
+  if (!quality) return {};
+  if (typeof quality === "number") {
+    return { maxStreamingBitrate: quality };
+  }
+  if (typeof quality === "string") {
+    const key = quality.toLowerCase();
+    if (VIDEO_QUALITY_PRESETS[key]) {
+      const preset = VIDEO_QUALITY_PRESETS[key];
+      return {
+        maxStreamingBitrate: preset.bitrate,
+        maxWidth: preset.maxWidth,
+        maxHeight: preset.maxHeight
+      };
+    }
+    const parsed = parseInt(quality, 10);
+    if (!Number.isNaN(parsed)) {
+      return { maxStreamingBitrate: parsed };
+    }
+    return {};
+  }
+  if (typeof quality === "object") {
+    return {
+      maxStreamingBitrate: quality.bitrate,
+      maxWidth: quality.maxWidth,
+      maxHeight: quality.maxHeight
+    };
+  }
+  return {};
+}
+function resolveAudioQuality(quality) {
+  if (!quality) return {};
+  if (typeof quality === "number") {
+    return { maxStreamingBitrate: quality };
+  }
+  if (typeof quality === "string") {
+    const key = quality.toLowerCase();
+    if (AUDIO_QUALITY_PRESETS[key]) {
+      return { maxStreamingBitrate: AUDIO_QUALITY_PRESETS[key].bitrate };
+    }
+    const parsed = parseInt(quality, 10);
+    if (!Number.isNaN(parsed)) {
+      return { maxStreamingBitrate: parsed };
+    }
+    return {};
+  }
+  if (typeof quality === "object" && quality.bitrate) {
+    return { maxStreamingBitrate: quality.bitrate };
+  }
+  return {};
+}
+function formatBitrate(bitrate) {
+  if (!bitrate || bitrate <= 0) return "Direct";
+  if (bitrate >= 1e6) {
+    const mbps = bitrate / 1e6;
+    return `${Number.isInteger(mbps) ? mbps : mbps.toFixed(1)} Mbps`;
+  }
+  const kbps = Math.round(bitrate / 1e3);
+  return `${kbps} kbps`;
+}
+
+// src/media.ts
+var MediaModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  /**
+   * Constructs the URL for an item's image/artwork.
+   * If the item lacks images or server is not set, returns options.fallbackUrl or null.
+   */
+  getArtworkUrl(itemOrId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const {
+      imageType = "Primary",
+      maxWidth = 400,
+      maxHeight,
+      quality = 90,
+      fallbackUrl = null
+    } = options;
+    if (!serverUrl || !itemOrId) return fallbackUrl;
+    if (typeof itemOrId === "object") {
+      const item = itemOrId;
+      let targetId = null;
+      let tag = null;
+      if (item.ImageTags && item.ImageTags[imageType]) {
+        targetId = item.Id;
+        tag = item.ImageTags[imageType];
+      } else if (imageType === "Primary" && item.PrimaryImageTag) {
+        targetId = item.Id;
+        tag = item.PrimaryImageTag;
+      } else if (imageType === "Primary" && item.AlbumPrimaryImageTag && item.AlbumId) {
+        targetId = item.AlbumId;
+        tag = item.AlbumPrimaryImageTag;
+      }
+      if (!targetId || !tag) {
+        return fallbackUrl;
+      }
+      const params = new URLSearchParams({
+        maxWidth: String(maxWidth),
+        quality: String(quality),
+        tag
+      });
+      if (maxHeight) params.append("maxHeight", String(maxHeight));
+      return `${serverUrl}/Items/${targetId}/Images/${imageType}?${params.toString()}`;
+    }
+    if (typeof itemOrId === "string" && itemOrId.trim() !== "") {
+      const params = new URLSearchParams({
+        maxWidth: String(maxWidth),
+        quality: String(quality)
+      });
+      if (maxHeight) params.append("maxHeight", String(maxHeight));
+      return `${serverUrl}/Items/${itemOrId}/Images/${imageType}?${params.toString()}`;
+    }
+    return fallbackUrl;
+  }
+  /**
+   * Constructs the audio stream URL using Jellyfin's universal audio endpoint.
+   * Transparently negotiates codecs (direct play or transcode to MP3/AAC as needed).
+   */
+  getAudioStreamUrl(itemId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const userId = this.getUserId();
+    const clientInfo = this.http.getClientInfo();
+    if (!serverUrl || !itemId) return "";
+    const qualityResolved = resolveAudioQuality(options.quality);
+    const maxStreamingBitrate = options.maxStreamingBitrate ?? qualityResolved.maxStreamingBitrate;
+    const {
+      startTimeTicks = 0,
+      container = "opus,mp3|mp3,aac,m4a,m4b,flac,wav,ogg",
+      transcodingContainer = "mp3",
+      audioCodec = "mp3",
+      useQueryToken = true
+    } = options;
+    const url = new URL(`${serverUrl}/Audio/${itemId}/universal`);
+    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (userId) url.searchParams.append("UserId", userId);
+    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    url.searchParams.append("Container", container);
+    url.searchParams.append("TranscodingContainer", transcodingContainer);
+    url.searchParams.append("TranscodingProtocol", "http");
+    url.searchParams.append("AudioCodec", audioCodec);
+    if (maxStreamingBitrate && maxStreamingBitrate !== "Direct") {
+      url.searchParams.append("MaxStreamingBitrate", String(maxStreamingBitrate));
+    }
+    if (startTimeTicks > 0) {
+      url.searchParams.append("StartTimeTicks", String(startTimeTicks));
+    }
+    url.searchParams.append("EnableRedirection", "true");
+    url.searchParams.append("EnableRemoteMedia", "false");
+    return url.toString();
+  }
+  /**
+   * Constructs the HLS master playlist URL for an audio stream.
+   */
+  getAudioHlsStreamUrl(itemId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const userId = this.getUserId();
+    const clientInfo = this.http.getClientInfo();
+    if (!serverUrl || !itemId) return "";
+    const qualityResolved = resolveAudioQuality(options.quality);
+    const maxStreamingBitrate = options.maxStreamingBitrate ?? qualityResolved.maxStreamingBitrate;
+    const {
+      startTimeTicks = 0,
+      audioCodec = "aac,mp3",
+      segmentLength = 3,
+      useQueryToken = true
+    } = options;
+    const url = new URL(`${serverUrl}/Audio/${itemId}/master.m3u8`);
+    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (userId) url.searchParams.append("UserId", userId);
+    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    url.searchParams.append("MediaSourceId", itemId);
+    url.searchParams.append("AudioCodec", audioCodec);
+    url.searchParams.append("TranscodingContainer", "ts");
+    url.searchParams.append("TranscodingProtocol", "hls");
+    url.searchParams.append("SegmentLength", String(segmentLength));
+    url.searchParams.append("MinSegments", "2");
+    if (maxStreamingBitrate && maxStreamingBitrate !== "Direct") {
+      url.searchParams.append("MaxStreamingBitrate", String(maxStreamingBitrate));
+    }
+    if (startTimeTicks > 0) {
+      url.searchParams.append("StartTimeTicks", String(startTimeTicks));
+    }
+    return url.toString();
+  }
+  /**
+   * Constructs the progressive/universal video stream URL.
+   * Supports direct play (static=true) or on-the-fly transcoding with quality, audio, and subtitle options.
+   */
+  getVideoStreamUrl(itemId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const userId = this.getUserId();
+    const clientInfo = this.http.getClientInfo();
+    if (!serverUrl || !itemId) return "";
+    const qualityResolved = resolveVideoQuality(options.quality);
+    const maxStreamingBitrate = options.maxStreamingBitrate ?? qualityResolved.maxStreamingBitrate;
+    const maxWidth = options.maxWidth ?? qualityResolved.maxWidth;
+    const maxHeight = options.maxHeight ?? qualityResolved.maxHeight;
+    const {
+      mediaSourceId = itemId,
+      static: isStatic = false,
+      videoCodec = "h264,hevc,vp9,av1",
+      audioCodec = "aac,mp3,opus,flac",
+      maxFramerate,
+      audioStreamIndex,
+      subtitleStreamIndex,
+      subtitleMethod,
+      startTimeTicks = 0,
+      container,
+      transcodingContainer = "ts",
+      transcodingProtocol = "http",
+      useQueryToken = true
+    } = options;
+    const endpoint = container && !container.includes(",") ? `/Videos/${itemId}/stream.${container}` : `/Videos/${itemId}/stream`;
+    const url = new URL(`${serverUrl}${endpoint}`);
+    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (userId) url.searchParams.append("UserId", userId);
+    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    if (mediaSourceId) url.searchParams.append("MediaSourceId", mediaSourceId);
+    if (isStatic) {
+      url.searchParams.append("Static", "true");
+    } else {
+      url.searchParams.append("VideoCodec", videoCodec);
+      url.searchParams.append("AudioCodec", audioCodec);
+      url.searchParams.append("TranscodingContainer", transcodingContainer);
+      url.searchParams.append("TranscodingProtocol", transcodingProtocol);
+      if (maxStreamingBitrate && maxStreamingBitrate !== "Direct") {
+        url.searchParams.append("MaxStreamingBitrate", String(maxStreamingBitrate));
+      }
+      if (maxWidth) url.searchParams.append("MaxWidth", String(maxWidth));
+      if (maxHeight) url.searchParams.append("MaxHeight", String(maxHeight));
+      if (maxFramerate) url.searchParams.append("MaxFramerate", String(maxFramerate));
+    }
+    if (audioStreamIndex !== void 0 && audioStreamIndex !== null) {
+      url.searchParams.append("AudioStreamIndex", String(audioStreamIndex));
+    }
+    if (subtitleStreamIndex !== void 0 && subtitleStreamIndex !== null) {
+      url.searchParams.append("SubtitleStreamIndex", String(subtitleStreamIndex));
+      if (subtitleMethod) url.searchParams.append("SubtitleMethod", subtitleMethod);
+    }
+    if (startTimeTicks > 0) {
+      url.searchParams.append("StartTimeTicks", String(startTimeTicks));
+    }
+    url.searchParams.append("EnableRedirection", "true");
+    url.searchParams.append("EnableRemoteMedia", "false");
+    return url.toString();
+  }
+  /**
+   * Constructs the HLS master playlist URL for an adaptive video stream.
+   */
+  getVideoHlsStreamUrl(itemId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const userId = this.getUserId();
+    const clientInfo = this.http.getClientInfo();
+    if (!serverUrl || !itemId) return "";
+    const qualityResolved = resolveVideoQuality(options.quality);
+    const maxStreamingBitrate = options.maxStreamingBitrate ?? qualityResolved.maxStreamingBitrate;
+    const maxWidth = options.maxWidth ?? qualityResolved.maxWidth;
+    const maxHeight = options.maxHeight ?? qualityResolved.maxHeight;
+    const {
+      mediaSourceId = itemId,
+      videoCodec = "h264,hevc,vp9,av1",
+      audioCodec = "aac,mp3,opus",
+      maxFramerate,
+      segmentLength = 3,
+      minSegments = 2,
+      audioStreamIndex,
+      subtitleStreamIndex,
+      subtitleMethod,
+      transcodingContainer = "ts",
+      transcodingProtocol = "hls",
+      startTimeTicks = 0,
+      useQueryToken = true
+    } = options;
+    const url = new URL(`${serverUrl}/Videos/${itemId}/master.m3u8`);
+    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (userId) url.searchParams.append("UserId", userId);
+    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    if (mediaSourceId) url.searchParams.append("MediaSourceId", mediaSourceId);
+    url.searchParams.append("VideoCodec", videoCodec);
+    url.searchParams.append("AudioCodec", audioCodec);
+    url.searchParams.append("TranscodingContainer", transcodingContainer);
+    url.searchParams.append("TranscodingProtocol", transcodingProtocol);
+    url.searchParams.append("SegmentLength", String(segmentLength));
+    url.searchParams.append("MinSegments", String(minSegments));
+    if (maxStreamingBitrate && maxStreamingBitrate !== "Direct") {
+      url.searchParams.append("MaxStreamingBitrate", String(maxStreamingBitrate));
+    }
+    if (maxWidth) url.searchParams.append("MaxWidth", String(maxWidth));
+    if (maxHeight) url.searchParams.append("MaxHeight", String(maxHeight));
+    if (maxFramerate) url.searchParams.append("MaxFramerate", String(maxFramerate));
+    if (audioStreamIndex !== void 0 && audioStreamIndex !== null) {
+      url.searchParams.append("AudioStreamIndex", String(audioStreamIndex));
+    }
+    if (subtitleStreamIndex !== void 0 && subtitleStreamIndex !== null) {
+      url.searchParams.append("SubtitleStreamIndex", String(subtitleStreamIndex));
+      if (subtitleMethod) url.searchParams.append("SubtitleMethod", subtitleMethod);
+    }
+    if (startTimeTicks > 0) {
+      url.searchParams.append("StartTimeTicks", String(startTimeTicks));
+    }
+    return url.toString();
+  }
+  /**
+   * Constructs the URL for streaming a specific subtitle track.
+   */
+  getSubtitleUrl(itemId, mediaSourceId, subtitleStreamIndex, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const { format = "vtt", useQueryToken = true, startTimeTicks = 0 } = options;
+    if (!serverUrl || !itemId) return "";
+    const sourceId = mediaSourceId || itemId;
+    const url = new URL(`${serverUrl}/Videos/${itemId}/${sourceId}/Subtitles/${subtitleStreamIndex}/Stream.${format}`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+    }
+    if (startTimeTicks > 0) {
+      url.searchParams.append("StartTimeTicks", String(startTimeTicks));
+    }
+    return url.toString();
+  }
+  /**
+   * Fetches subtitle content as raw text (e.g. WebVTT or SRT format).
+   */
+  async getSubtitles(itemId, mediaSourceId, subtitleStreamIndex, options = {}) {
+    const { format = "vtt", startTimeTicks = 0 } = options;
+    const sourceId = mediaSourceId || itemId;
+    const params = {};
+    if (startTimeTicks > 0) {
+      params.StartTimeTicks = startTimeTicks;
+    }
+    return await this.http.requestText(
+      `/Videos/${itemId}/${sourceId}/Subtitles/${subtitleStreamIndex}/Stream.${format}`,
+      { params }
+    );
+  }
+  /**
+   * Extracts and normalizes subtitle streams from an item or media source into SubtitleTrackInfo objects with URLs.
+   */
+  getSubtitleTracks(itemOrMediaSource) {
+    if (!itemOrMediaSource) return [];
+    let streams = [];
+    let itemId = "";
+    let mediaSourceId = "";
+    if ("MediaSources" in itemOrMediaSource && Array.isArray(itemOrMediaSource.MediaSources)) {
+      itemId = itemOrMediaSource.Id;
+      const primarySource = itemOrMediaSource.MediaSources[0];
+      if (primarySource) {
+        mediaSourceId = primarySource.Id || itemId;
+        streams = primarySource.MediaStreams || [];
+      }
+    } else if ("MediaStreams" in itemOrMediaSource && Array.isArray(itemOrMediaSource.MediaStreams)) {
+      const source = itemOrMediaSource;
+      mediaSourceId = source.Id || "";
+      itemId = mediaSourceId;
+      streams = source.MediaStreams || [];
+    }
+    return streams.filter((s) => s.Type === "Subtitle").map((s) => {
+      const index = s.Index ?? 0;
+      const codec = (s.Codec || "vtt").toLowerCase();
+      const preferredFormat = codec === "subrip" || codec === "srt" ? "srt" : "vtt";
+      const url = itemId ? this.getSubtitleUrl(itemId, mediaSourceId, index, { format: preferredFormat }) : "";
+      return {
+        index,
+        codec: s.Codec || "vtt",
+        language: s.Language,
+        displayTitle: s.DisplayTitle || s.Language || `Subtitle ${index}`,
+        displayLanguage: s.DisplayLanguage,
+        isDefault: !!s.IsDefault,
+        isForced: !!s.IsForced,
+        isExternal: !!s.IsExternal,
+        deliveryMethod: s.DeliveryMethod,
+        deliveryUrl: s.DeliveryUrl,
+        url
+      };
+    });
+  }
+  /**
+   * Constructs the direct download URL for an original, unmodified media file on the Jellyfin server.
+   */
+  getDownloadUrl(itemId, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const { useQueryToken = true, filename } = options;
+    if (!serverUrl || !itemId) return "";
+    const url = new URL(`${serverUrl}/Items/${itemId}/Download`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+    }
+    if (filename) {
+      url.searchParams.append("filename", filename);
+    }
+    return url.toString();
+  }
+  /**
+   * Downloads a media file as a Blob with optional progress monitoring.
+   */
+  async downloadFile(itemId, options = {}) {
+    const downloadUrl = this.getDownloadUrl(itemId, { useQueryToken: options.useQueryToken });
+    if (!downloadUrl) {
+      throw new Error("Cannot construct download URL: missing serverUrl or itemId");
+    }
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      throw new Error(`Download failed with status ${response.status}: ${response.statusText}`);
+    }
+    const contentLength = parseInt(response.headers.get("Content-Length") || "0", 10) || 0;
+    const reader = response.body ? response.body.getReader() : null;
+    if (reader && contentLength > 0) {
+      const chunks = [];
+      let received = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          chunks.push(value);
+          received += value.length;
+          if (options.onProgress) {
+            options.onProgress(received / contentLength);
+          }
+        }
+      }
+      return new Blob(chunks, { type: response.headers.get("Content-Type") || "application/octet-stream" });
+    }
+    const blob = await response.blob();
+    if (options.onProgress) {
+      options.onProgress(1);
+    }
+    return blob;
+  }
+  /**
+   * Returns authentication headers for media streaming requests (e.g., configuring hls.js xhrSetup).
+   * Crucial for Jellyfin 12+ servers where query-based auth (?api_key=) is disabled.
+   */
+  getStreamHeaders() {
+    const authHeader = this.http.getAuthHeader();
+    return {
+      Authorization: authHeader,
+      "X-Emby-Authorization": authHeader
+    };
+  }
+};
+
+// src/lyrics.ts
+var LyricsModule = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Fetch synced or unsynced lyrics for an audio item.
+   */
+  async getLyrics(itemId) {
+    if (!itemId) return null;
+    try {
+      return await this.http.request(`/Audio/${itemId}/Lyrics`);
+    } catch (err) {
+      console.warn("[Jellyfin SDK] Failed to fetch lyrics:", err);
+      return null;
+    }
+  }
+};
+
+// src/favorites.ts
+var FavoritesModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  requireUserId() {
+    const userId = this.getUserId();
+    if (!userId) {
+      throw new JellyfinError("User ID is required to mark favorites.");
+    }
+    return userId;
+  }
+  /**
+   * Mark an item as favorite.
+   */
+  async markFavorite(itemId) {
+    if (!itemId) return;
+    const userId = this.requireUserId();
+    await this.http.request(`/Users/${userId}/FavoriteItems/${itemId}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Unmark an item as favorite.
+   */
+  async unmarkFavorite(itemId) {
+    if (!itemId) return;
+    const userId = this.requireUserId();
+    await this.http.request(`/Users/${userId}/FavoriteItems/${itemId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/offline.ts
+var OfflineStorageManager = class {
+  media;
+  dbName;
+  dbVersion;
+  storeName;
+  dbPromise = null;
+  objectUrlCache = /* @__PURE__ */ new Map();
+  downloadStatusCache = /* @__PURE__ */ new Map();
+  constructor(media, dbName = "JellyfinOfflineAudio", dbVersion = 1, storeName = "tracks") {
+    this.media = media;
+    this.dbName = dbName;
+    this.dbVersion = dbVersion;
+    this.storeName = storeName;
+  }
+  isSupported() {
+    return typeof window !== "undefined" && "indexedDB" in window;
+  }
+  async initDB() {
+    if (this.dbPromise) return this.dbPromise;
+    this.dbPromise = new Promise((resolve) => {
+      if (!this.isSupported()) {
+        resolve(null);
+        return;
+      }
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: "id" });
+        }
+      };
+      request.onsuccess = (event) => {
+        resolve(event.target.result);
+      };
+      request.onerror = (event) => {
+        console.warn("[Jellyfin Offline] IndexedDB open error:", event.target.error);
+        resolve(null);
+      };
+    });
+    return this.dbPromise;
+  }
+  getItemKey(item) {
+    return item ? String(item.Id || item.id || "") : "";
+  }
+  dispatchDownloadChanged(itemId, downloaded) {
+    if (typeof window === "undefined") return;
+    window.dispatchEvent(
+      new CustomEvent("jellyfin-download-changed", {
+        detail: { itemId, trackId: itemId, downloaded }
+      })
+    );
+  }
+  revokeObjectUrl(id) {
+    const url = this.objectUrlCache.get(id);
+    if (url) {
+      try {
+        URL.revokeObjectURL(url);
+      } catch {
+      }
+      this.objectUrlCache.delete(id);
+    }
+  }
+  async getDownloadedRecord(id) {
+    if (!id) return null;
+    try {
+      const db = await this.initDB();
+      if (!db) return null;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readonly");
+        const store = tx.objectStore(this.storeName);
+        const request = store.get(String(id));
+        request.onsuccess = () => resolve(request.result || null);
+        request.onerror = () => resolve(null);
+      });
+    } catch (err) {
+      console.warn(`[Jellyfin Offline] getDownloadedRecord error for ${id}:`, err);
+      return null;
+    }
+  }
+  async isItemDownloaded(id) {
+    if (!id) return false;
+    const key = String(id);
+    if (this.downloadStatusCache.has(key)) {
+      return this.downloadStatusCache.get(key);
+    }
+    const record = await this.getDownloadedRecord(key);
+    const exists = !!record;
+    this.downloadStatusCache.set(key, exists);
+    return exists;
+  }
+  isItemDownloadedSync(id) {
+    if (!id) return false;
+    return this.downloadStatusCache.get(String(id)) === true;
+  }
+  // Backward compatibility aliases
+  async isTrackDownloaded(id) {
+    return this.isItemDownloaded(id);
+  }
+  isTrackDownloadedSync(id) {
+    return this.isItemDownloadedSync(id);
+  }
+  async getDownloadedBlobUrl(id) {
+    if (!id) return null;
+    const key = String(id);
+    if (this.objectUrlCache.has(key)) return this.objectUrlCache.get(key);
+    const record = await this.getDownloadedRecord(key);
+    if (!record || !record.blob) return null;
+    const url = URL.createObjectURL(record.blob);
+    this.objectUrlCache.set(key, url);
+    return url;
+  }
+  getDownloadedBlobUrlSync(id) {
+    if (!id) return null;
+    return this.objectUrlCache.get(String(id)) || null;
+  }
+  async getAllDownloads() {
+    try {
+      const db = await this.initDB();
+      if (!db) return [];
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readonly");
+        const store = tx.objectStore(this.storeName);
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const records = request.result || [];
+          resolve(records.sort((a, b) => (b.savedAt || 0) - (a.savedAt || 0)));
+        };
+        request.onerror = () => resolve([]);
+      });
+    } catch (err) {
+      console.warn("[Jellyfin Offline] getAllDownloads error:", err);
+      return [];
+    }
+  }
+  async warmOfflineCache() {
+    try {
+      const downloads = await this.getAllDownloads();
+      for (const item of downloads) {
+        if (item && item.id) {
+          const key = String(item.id);
+          this.downloadStatusCache.set(key, true);
+          if (item.blob && !this.objectUrlCache.has(key)) {
+            try {
+              this.objectUrlCache.set(key, URL.createObjectURL(item.blob));
+            } catch {
+            }
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[Jellyfin Offline] warmOfflineCache error:", err);
+    }
+  }
+  async saveDownloadRecord(record, blob) {
+    try {
+      const db = await this.initDB();
+      if (!db) return false;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const entry = { ...record, blob };
+        const request = store.put(entry);
+        request.onsuccess = () => resolve(true);
+        request.onerror = () => resolve(false);
+      });
+    } catch (err) {
+      console.warn("[Jellyfin Offline] saveDownloadRecord error:", err);
+      return false;
+    }
+  }
+  async removeDownload(id) {
+    if (!id) return false;
+    const key = String(id);
+    try {
+      const db = await this.initDB();
+      if (!db) return false;
+      const removed = await new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onsuccess = () => resolve(true);
+        request.onerror = () => resolve(false);
+      });
+      if (removed) {
+        this.revokeObjectUrl(key);
+        this.downloadStatusCache.set(key, false);
+        this.dispatchDownloadChanged(key, false);
+      }
+      return removed;
+    } catch (err) {
+      console.warn("[Jellyfin Offline] removeDownload error:", err);
+      return false;
+    }
+  }
+  /**
+   * Downloads an audio or video item to offline storage.
+   * If already downloaded, toggles it off (removes it).
+   */
+  async downloadItem(item, onProgress, group, index, options = {}) {
+    if (!item) return { ok: false, error: "no-item" };
+    const key = this.getItemKey(item);
+    if (!key) return { ok: false, error: "no-id" };
+    if (await this.isItemDownloaded(key)) {
+      await this.removeDownload(key);
+      return { ok: true, removed: true };
+    }
+    const isVideo = item.MediaType === "Video" || item.Type === "Movie" || item.Type === "Episode" || item.Type === "Video";
+    let sourceUrl = "";
+    if (isVideo) {
+      if (options.quality) {
+        sourceUrl = this.media.getVideoStreamUrl(key, { quality: options.quality });
+      } else {
+        sourceUrl = this.media.getDownloadUrl(key);
+      }
+    } else {
+      sourceUrl = this.media.getAudioStreamUrl(key, { maxStreamingBitrate: "Direct" });
+    }
+    if (!sourceUrl) return { ok: false, error: "no-url" };
+    let response;
+    try {
+      response = await fetch(sourceUrl);
+    } catch (err) {
+      console.warn("[Jellyfin Offline] Download fetch error:", err);
+      return { ok: false, error: "network" };
+    }
+    if (!response.ok) {
+      return { ok: false, error: `http-${response.status}` };
+    }
+    const contentLength = parseInt(response.headers.get("Content-Length") || "0", 10) || 0;
+    try {
+      const reader = response.body ? response.body.getReader() : null;
+      let blob;
+      const mimeType = response.headers.get("Content-Type") || (isVideo ? "video/mp4" : "audio/mpeg");
+      if (reader) {
+        const chunks = [];
+        let received = 0;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) {
+            chunks.push(value);
+            received += value.length;
+            if (onProgress) {
+              onProgress(contentLength > 0 ? received / contentLength : 0);
+            }
+          }
+        }
+        blob = new Blob(chunks, { type: mimeType });
+      } else {
+        blob = await response.blob();
+        if (onProgress) onProgress(1);
+      }
+      const record = {
+        id: key,
+        name: item.Name || "Unknown",
+        mediaType: isVideo ? "Video" : "Audio",
+        type: item.Type,
+        artists: item.Artists ? item.Artists.join(", ") : item.AlbumArtist || "",
+        album: item.Album || "",
+        albumId: item.AlbumId || "",
+        seriesName: item.SeriesName || void 0,
+        seriesId: item.SeriesId || void 0,
+        seasonName: item.SeasonName || void 0,
+        seasonId: item.SeasonId || void 0,
+        artworkUrl: this.media.getArtworkUrl(item, { maxWidth: 300 }),
+        size: blob.size,
+        savedAt: Date.now(),
+        hasLyrics: !!item.HasLyrics,
+        mimeType
+      };
+      if (group && group.id) {
+        record.parentId = String(group.id);
+        record.parentName = group.name || "";
+        record.parentType = group.type || "";
+        record.parentArtworkUrl = group.artworkUrl || "";
+        record.parentOwner = group.owner || "";
+        record.parentCount = group.count || 0;
+      }
+      if (typeof index === "number" && !Number.isNaN(index)) {
+        record.index = index;
+      } else if (typeof item.IndexNumber === "number") {
+        record.index = item.IndexNumber;
+      }
+      const saved = await this.saveDownloadRecord(record, blob);
+      if (!saved) return { ok: false, error: "storage" };
+      this.revokeObjectUrl(key);
+      this.downloadStatusCache.set(key, true);
+      this.dispatchDownloadChanged(key, true);
+      return { ok: true, size: blob.size };
+    } catch (err) {
+      console.warn("[Jellyfin Offline] Download processing failed:", err);
+      return { ok: false, error: "unknown" };
+    }
+  }
+  /**
+   * Backward-compatible alias for downloadItem.
+   */
+  async downloadTrack(track, onProgress, group, index) {
+    return this.downloadItem(track, onProgress, group, index);
+  }
+  /**
+   * Downloads multiple items with aggregated progress callbacks.
+   */
+  async downloadItems(items, onProgress, group, options = {}) {
+    const targets = [];
+    for (const item of items || []) {
+      const key = item && (item.Id || item.id);
+      if (key && !await this.isItemDownloaded(key)) {
+        targets.push(item);
+      }
+    }
+    const total = targets.length;
+    let completed = 0;
+    let failed = 0;
+    for (let i = 0; i < targets.length; i++) {
+      const res = await this.downloadItem(targets[i], void 0, group, i, options);
+      completed++;
+      if (!res.ok) failed++;
+      if (onProgress) {
+        onProgress({ completed, total, item: targets[i], track: targets[i], res });
+      }
+    }
+    return { ok: failed === 0 && total > 0, downloaded: total - failed, failed, total };
+  }
+  /**
+   * Backward-compatible alias for downloadItems.
+   */
+  async downloadTracks(tracks, onProgress, group) {
+    return this.downloadItems(tracks, onProgress, group);
+  }
+  async removeDownloads(items) {
+    let removed = 0;
+    for (const item of items || []) {
+      const key = item && (item.Id || item.id);
+      if (key && await this.removeDownload(key)) removed++;
+    }
+    return { ok: removed > 0, removed };
+  }
+  formatBytes(bytes) {
+    if (!bytes || bytes <= 0) return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    return `${(bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+  }
+};
+
+// src/cache.ts
+var MemoryCacheAdapter = class {
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.cache.get(key);
+    return entry ? entry.data : null;
+  }
+  set(key, data) {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var IndexedDBCacheAdapter = class {
+  dbName;
+  dbVersion;
+  storeName;
+  dbPromise = null;
+  constructor(dbName = "JellyfinSdkCache", dbVersion = 1, storeName = "api_cache") {
+    this.dbName = dbName;
+    this.dbVersion = dbVersion;
+    this.storeName = storeName;
+  }
+  async getDB() {
+    if (this.dbPromise) return this.dbPromise;
+    this.dbPromise = new Promise((resolve) => {
+      if (typeof window === "undefined" || !("indexedDB" in window)) {
+        resolve(null);
+        return;
+      }
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: "key" });
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = (e) => {
+        console.warn("[Jellyfin Cache] IndexedDB open error:", e);
+        resolve(null);
+      };
+    });
+    return this.dbPromise;
+  }
+  async get(key) {
+    try {
+      const db = await this.getDB();
+      if (!db) return null;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readonly");
+        const store = tx.objectStore(this.storeName);
+        const request = store.get(key);
+        request.onsuccess = () => {
+          const record = request.result;
+          resolve(record ? record.data : null);
+        };
+        request.onerror = () => resolve(null);
+      });
+    } catch {
+      return null;
+    }
+  }
+  async set(key, data) {
+    if (!data) return;
+    try {
+      const db = await this.getDB();
+      if (!db) return;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const record = { key, data, timestamp: Date.now() };
+        const request = store.put(record);
+        request.onsuccess = () => resolve();
+        request.onerror = () => resolve();
+      });
+    } catch {
+    }
+  }
+  async delete(key) {
+    try {
+      const db = await this.getDB();
+      if (!db) return;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onsuccess = () => resolve();
+        request.onerror = () => resolve();
+      });
+    } catch {
+    }
+  }
+  async clear() {
+    try {
+      const db = await this.getDB();
+      if (!db) return;
+      return new Promise((resolve) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const request = store.clear();
+        request.onsuccess = () => resolve();
+        request.onerror = () => resolve();
+      });
+    } catch {
+    }
+  }
+};
+async function fetchWithCache(cache, cacheKey, fetchFn, onFreshData) {
+  const cached = await cache.get(cacheKey);
+  const backgroundFetch = fetchFn().then(async (freshData) => {
+    if (freshData !== null && freshData !== void 0) {
+      await cache.set(cacheKey, freshData);
+      if (onFreshData) {
+        try {
+          onFreshData(freshData);
+        } catch (e) {
+          console.warn("[Jellyfin Cache] Error in onFreshData callback for %s:", cacheKey, e);
+        }
+      }
+    }
+    return freshData;
+  }).catch((err) => {
+    console.warn("[Jellyfin Cache] Background fetch failed for %s:", cacheKey, err);
+    if (!cached) throw err;
+    return cached;
+  });
+  if (cached !== null && cached !== void 0) {
+    return cached;
+  }
+  return await backgroundFetch;
+}
+
+// src/storage.ts
+var MemoryStorage = class {
+  store = /* @__PURE__ */ new Map();
+  getItem(key) {
+    return this.store.has(key) ? this.store.get(key) : null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+var LocalStorageAdapter = class {
+  getItem(key) {
+    if (typeof localStorage !== "undefined") {
+      return localStorage.getItem(key);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(key, value);
+    }
+  }
+  removeItem(key) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(key);
+    }
+  }
+};
+function getDefaultStorage() {
+  if (typeof window !== "undefined" && typeof window.localStorage !== "undefined") {
+    return new LocalStorageAdapter();
+  }
+  return new MemoryStorage();
+}
+function generateDeviceId() {
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    return "sdk-" + Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return "sdk-" + Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+
+// src/client.ts
+var JellyfinClient = class {
+  auth;
+  system;
+  library;
+  playlists;
+  playback;
+  media;
+  lyrics;
+  favorites;
+  offline;
+  http;
+  storage;
+  cache;
+  clientInfo;
+  eventListeners = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.storage = options.storage || getDefaultStorage();
+    this.cache = new MemoryCacheAdapter();
+    this.clientInfo = {
+      name: options.clientInfo?.name || "@francofantomius/jellyfin",
+      version: options.clientInfo?.version || "0.1.0",
+      device: options.clientInfo?.device || (typeof window !== "undefined" ? "Web Browser" : "Node.js"),
+      deviceId: options.clientInfo?.deviceId || generateDeviceId()
+    };
+    this.http = new HttpTransport({
+      serverUrl: options.serverUrl,
+      token: options.accessToken,
+      clientInfo: this.clientInfo,
+      fetch: options.fetch,
+      onUnauthorized: () => {
+        this.emit("unauthorized");
+        if (options.onUnauthorized) {
+          options.onUnauthorized();
+        }
+      }
+    });
+    const getUserId = () => this.auth.getUserId();
+    this.system = new SystemModule(this.http, {
+      serverVersion: options.serverVersion,
+      targetVersion: options.targetVersion
+    });
+    this.auth = new AuthModule(this.http, options.userId || "");
+    this.library = new LibraryModule(this.http, getUserId);
+    this.playlists = new PlaylistsModule(this.http, getUserId);
+    this.playback = new PlaybackModule(this.http);
+    this.media = new MediaModule(this.http, getUserId);
+    this.lyrics = new LyricsModule(this.http);
+    this.favorites = new FavoritesModule(this.http, getUserId);
+    this.offline = new OfflineStorageManager(this.media);
+  }
+  // --- Configuration Getters & Setters ---
+  get serverUrl() {
+    return this.http.getServerUrl();
+  }
+  set serverUrl(url) {
+    this.http.setServerUrl(url);
+  }
+  get accessToken() {
+    return this.http.getToken();
+  }
+  set accessToken(token) {
+    this.http.setToken(token);
+  }
+  get userId() {
+    return this.auth.getUserId();
+  }
+  set userId(id) {
+    this.auth.setUserId(id);
+  }
+  get serverVersion() {
+    return this.system.getVersion();
+  }
+  set serverVersion(version) {
+    this.system.setVersion(version);
+  }
+  /**
+   * Check whether the connected Jellyfin server is version 12.0 or higher.
+   */
+  async isV12() {
+    return await this.system.isV12();
+  }
+  /**
+   * Query server and detect the server version via /System/Info/Public.
+   */
+  async detectServerVersion() {
+    return await this.system.detectVersion();
+  }
+  get info() {
+    return this.http.getClientInfo();
+  }
+  setClientInfo(info) {
+    this.http.setClientInfo(info);
+  }
+  getCache() {
+    return this.cache;
+  }
+  setCache(cache) {
+    this.cache = cache;
+  }
+  getStorage() {
+    return this.storage;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  // --- Event Handling ---
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  off(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  emit(event, ...args) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((fn) => {
+        try {
+          fn(...args);
+        } catch (e) {
+          console.error(`[Jellyfin SDK] Event handler error on '${event}':`, e);
+        }
+      });
+    }
+  }
+  // --- Convenience Shortcuts ---
+  /**
+   * Authenticate with username and password, update client state, and emit 'authenticated'.
+   */
+  async authenticate(username, password = "") {
+    const res = await this.auth.authenticateByName(username, password);
+    if (!this.system.getVersion()) {
+      this.system.detectVersion().catch(() => {
+      });
+    }
+    this.emit("authenticated", res);
+    return res;
+  }
+  /**
+   * Log out and clear tokens and session.
+   */
+  logout() {
+    this.auth.logout();
+    this.emit("logout");
+  }
+  /**
+   * Manually set authentication credentials.
+   */
+  setCredentials(credentials) {
+    if (credentials.serverUrl) {
+      this.http.setServerUrl(credentials.serverUrl);
+    }
+    this.http.setToken(credentials.accessToken);
+    this.auth.setUserId(credentials.userId);
+  }
+};
+
+exports.AUDIO_QUALITY_PRESETS = AUDIO_QUALITY_PRESETS;
+exports.AuthModule = AuthModule;
+exports.FavoritesModule = FavoritesModule;
+exports.HttpTransport = HttpTransport;
+exports.IndexedDBCacheAdapter = IndexedDBCacheAdapter;
+exports.JellyfinApiError = JellyfinApiError;
+exports.JellyfinAuthError = JellyfinAuthError;
+exports.JellyfinClient = JellyfinClient;
+exports.JellyfinError = JellyfinError;
+exports.LibraryModule = LibraryModule;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.LyricsModule = LyricsModule;
+exports.MediaModule = MediaModule;
+exports.MemoryCacheAdapter = MemoryCacheAdapter;
+exports.MemoryStorage = MemoryStorage;
+exports.OfflineStorageManager = OfflineStorageManager;
+exports.PlaybackModule = PlaybackModule;
+exports.PlaylistsModule = PlaylistsModule;
+exports.SystemModule = SystemModule;
+exports.VIDEO_QUALITY_PRESETS = VIDEO_QUALITY_PRESETS;
+exports.buildAuthHeader = buildAuthHeader;
+exports.cleanUrl = cleanUrl;
+exports.fetchWithCache = fetchWithCache;
+exports.formatBitrate = formatBitrate;
+exports.generateDeviceId = generateDeviceId;
+exports.getAudioQualityList = getAudioQualityList;
+exports.getDefaultStorage = getDefaultStorage;
+exports.getVideoQualityList = getVideoQualityList;
+exports.isV12OrHigher = isV12OrHigher;
+exports.isVersionAtLeast = isVersionAtLeast;
+exports.parseSemVer = parseSemVer;
+exports.resolveAudioQuality = resolveAudioQuality;
+exports.resolveVideoQuality = resolveVideoQuality;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map