@francofantomius/jellyfin 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -125,7 +125,15 @@ var HttpTransport = class {
       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);
+      let details = "";
+      try {
+        const text = await response.text();
+        if (text) {
+          details = `: ${text.slice(0, 500)}`;
+        }
+      } catch {
+      }
+      throw new JellyfinApiError(`Jellyfin API request failed (${endpoint}): ${response.statusText || response.status}${details}`, response.status, endpoint);
     }
     return response;
   }
@@ -219,11 +227,22 @@ var AuthModule = class {
     const payload = {
       PlayableMediaTypes: ["Audio", "Video"],
       SupportedCommands: [
-        "Play",
+        "MoveUp",
+        "MoveDown",
+        "MoveLeft",
+        "MoveRight",
+        "Select",
+        "Back",
+        "VolumeUp",
+        "VolumeDown",
+        "Mute",
+        "Unmute",
+        "ToggleMute",
+        "SetVolume",
         "PlayState",
-        "PlayNext",
         "SetRepeatMode",
-        "SetShuffleQueue"
+        "SetShuffleQueue",
+        "DisplayMessage"
       ],
       SupportsMediaControl: true,
       SupportsSync: false,
@@ -1169,28 +1188,38 @@ var MediaModule = class {
     const qualityResolved = resolveAudioQuality(options.quality);
     const maxStreamingBitrate = options.maxStreamingBitrate ?? qualityResolved.maxStreamingBitrate;
     const {
+      static: isStatic = false,
       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);
+    const endpoint = isStatic ? `/Audio/${itemId}/stream` : `/Audio/${itemId}/universal`;
+    const url = new URL(`${serverUrl}${endpoint}`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", 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);
+    const targetDeviceId = options.deviceId !== void 0 ? options.deviceId : clientInfo.deviceId;
+    if (targetDeviceId) url.searchParams.append("DeviceId", targetDeviceId);
+    if (isStatic) {
+      url.searchParams.append("static", "true");
+    } else {
+      url.searchParams.append("Container", container);
+      url.searchParams.append("TranscodingContainer", transcodingContainer);
+      url.searchParams.append("TranscodingProtocol", "http");
+      url.searchParams.append("AudioCodec", audioCodec);
+      url.searchParams.append("EnableRedirection", "true");
+      url.searchParams.append("EnableRemoteMedia", "false");
+    }
     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();
   }
   /**
@@ -1211,9 +1240,13 @@ var MediaModule = class {
       useQueryToken = true
     } = options;
     const url = new URL(`${serverUrl}/Audio/${itemId}/master.m3u8`);
-    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
     if (userId) url.searchParams.append("UserId", userId);
-    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    const targetDeviceId = options.deviceId !== void 0 ? options.deviceId : clientInfo.deviceId;
+    if (targetDeviceId) url.searchParams.append("DeviceId", targetDeviceId);
     url.searchParams.append("MediaSourceId", itemId);
     url.searchParams.append("AudioCodec", audioCodec);
     url.searchParams.append("TranscodingContainer", "ts");
@@ -1259,9 +1292,13 @@ var MediaModule = class {
     } = 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 (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
     if (userId) url.searchParams.append("UserId", userId);
-    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    const targetDeviceId = options.deviceId !== void 0 ? options.deviceId : clientInfo.deviceId;
+    if (targetDeviceId) url.searchParams.append("DeviceId", targetDeviceId);
     if (mediaSourceId) url.searchParams.append("MediaSourceId", mediaSourceId);
     if (isStatic) {
       url.searchParams.append("Static", "true");
@@ -1320,9 +1357,13 @@ var MediaModule = class {
       useQueryToken = true
     } = options;
     const url = new URL(`${serverUrl}/Videos/${itemId}/master.m3u8`);
-    if (token && useQueryToken) url.searchParams.append("api_key", token);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
     if (userId) url.searchParams.append("UserId", userId);
-    if (clientInfo.deviceId) url.searchParams.append("DeviceId", clientInfo.deviceId);
+    const targetDeviceId = options.deviceId !== void 0 ? options.deviceId : clientInfo.deviceId;
+    if (targetDeviceId) url.searchParams.append("DeviceId", targetDeviceId);
     if (mediaSourceId) url.searchParams.append("MediaSourceId", mediaSourceId);
     url.searchParams.append("VideoCodec", videoCodec);
     url.searchParams.append("AudioCodec", audioCodec);
@@ -2219,191 +2260,1460 @@ var SearchModule = class {
   }
 };
 
-// src/cache.ts
-var MemoryCacheAdapter = class {
-  cache = /* @__PURE__ */ new Map();
-  get(key) {
-    const entry = this.cache.get(key);
-    return entry ? entry.data : null;
+// src/websocket.ts
+var WebSocketModule = class {
+  http;
+  getDeviceId;
+  ws = null;
+  keepAliveTimer = null;
+  reconnectTimer = null;
+  listeners = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  explicitlyClosed = false;
+  options = {};
+  constructor(http, getDeviceId) {
+    this.http = http;
+    this.getDeviceId = getDeviceId;
   }
-  set(key, data) {
-    this.cache.set(key, { data, timestamp: Date.now() });
+  /**
+   * Check whether the WebSocket is currently open and connected.
+   */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === 1;
   }
-  delete(key) {
-    this.cache.delete(key);
+  /**
+   * Build the Jellyfin WebSocket URL from current serverUrl, accessToken, and deviceId.
+   */
+  getWebSocketUrl() {
+    const serverUrl = this.http.getServerUrl();
+    if (!serverUrl) {
+      throw new JellyfinError("Server URL is required to connect to WebSocket.");
+    }
+    const token = this.http.getToken();
+    if (!token) {
+      throw new JellyfinError("Access token is required to connect to WebSocket. Please authenticate first.");
+    }
+    const deviceId = this.getDeviceId();
+    const wsBaseUrl = serverUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://").replace(/\/+$/, "");
+    const url = new URL(`${wsBaseUrl}/socket`);
+    url.searchParams.set("api_key", token);
+    if (deviceId) {
+      url.searchParams.set("deviceId", deviceId);
+    }
+    return url.toString();
   }
-  clear() {
-    this.cache.clear();
+  /**
+   * Connect to the Jellyfin WebSocket endpoint.
+   */
+  connect(options = {}) {
+    this.options = {
+      autoReconnect: true,
+      reconnectIntervalMs: 5e3,
+      maxReconnectAttempts: 10,
+      keepAliveIntervalMs: 3e4,
+      ...options
+    };
+    this.explicitlyClosed = false;
+    this.cleanup();
+    const socketUrl = this.options.url || this.getWebSocketUrl();
+    let SocketConstructor = this.options.webSocketFactory ? null : typeof globalThis !== "undefined" ? globalThis.WebSocket : null;
+    if (this.options.webSocketFactory) {
+      this.ws = this.options.webSocketFactory(socketUrl);
+    } else if (SocketConstructor) {
+      this.ws = new SocketConstructor(socketUrl);
+    } else {
+      throw new JellyfinError("WebSocket constructor is not available in the current environment. Please supply webSocketFactory in options.");
+    }
+    this.setupSocketEvents();
   }
-};
-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;
+  /**
+   * Disconnect the WebSocket and prevent automatic reconnection.
+   */
+  disconnect() {
+    this.explicitlyClosed = true;
+    this.cleanup();
   }
-  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);
-      };
+  /**
+   * Send a raw string or JSON message through the open WebSocket.
+   */
+  send(message) {
+    if (!this.isConnected) {
+      throw new JellyfinError("Cannot send message: WebSocket is not open.");
+    }
+    const payload = typeof message === "string" ? message : JSON.stringify(message);
+    this.ws.send(payload);
+  }
+  /**
+   * Send a KeepAlive message to the Jellyfin server.
+   */
+  sendKeepAlive() {
+    this.send({ MessageType: "KeepAlive" });
+  }
+  /**
+   * Subscribe to real-time session updates from the server.
+   */
+  startSessionsSubscription(intervalMs = 1500) {
+    this.send({
+      MessageType: "SessionsStart",
+      Data: `0,${intervalMs}`
     });
-    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;
-    }
+  /**
+   * Stop receiving real-time session updates.
+   */
+  stopSessionsSubscription() {
+    this.send({ MessageType: "SessionsStop" });
   }
-  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 {
-    }
+  /**
+   * Subscribe to scheduled tasks updates from the server.
+   */
+  startScheduledTasksSubscription(intervalMs = 1500) {
+    this.send({
+      MessageType: "ScheduledTasksInfoStart",
+      Data: `0,${intervalMs}`
+    });
   }
-  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 {
+  /**
+   * Stop scheduled tasks updates.
+   */
+  stopScheduledTasksSubscription() {
+    this.send({ MessageType: "ScheduledTasksInfoStop" });
+  }
+  /**
+   * Subscribe to server activity log updates.
+   */
+  startActivityLogSubscription(intervalMs = 1500) {
+    this.send({
+      MessageType: "ActivityLogEntryStart",
+      Data: `0,${intervalMs}`
+    });
+  }
+  /**
+   * Stop server activity log updates.
+   */
+  stopActivityLogSubscription() {
+    this.send({ MessageType: "ActivityLogEntryStop" });
+  }
+  on(event, listener) {
+    const key = event.toLowerCase();
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, /* @__PURE__ */ new Set());
     }
+    this.listeners.get(key).add(listener);
+    return () => this.off(key, listener);
   }
-  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 {
+  off(event, listener) {
+    const key = event.toLowerCase();
+    const set = this.listeners.get(key);
+    if (set) {
+      set.delete(listener);
     }
   }
-};
-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) {
+  emit(event, ...args) {
+    const key = event.toLowerCase();
+    const set = this.listeners.get(key);
+    if (set) {
+      set.forEach((listener) => {
         try {
-          onFreshData(freshData);
+          listener(...args);
         } catch (e) {
-          console.warn("[Jellyfin Cache] Error in onFreshData callback for %s:", cacheKey, e);
+          console.error(`[Jellyfin SDK] WebSocket listener error on '${event}':`, 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);
+  // --- Internal Socket Helpers ---
+  setupSocketEvents() {
+    if (!this.ws) return;
+    this.ws.onopen = () => {
+      this.reconnectAttempts = 0;
+      this.startKeepAlive();
+      this.emit("open");
+    };
+    this.ws.onclose = (ev) => {
+      this.stopKeepAlive();
+      this.emit("close", ev?.code, ev?.reason);
+      if (!this.explicitlyClosed && this.options.autoReconnect) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = (err) => {
+      this.emit("error", err);
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const text = typeof event.data === "string" ? event.data : String(event.data);
+        const parsed = JSON.parse(text);
+        this.emit("message", parsed);
+        if (parsed.MessageType) {
+          this.emit(parsed.MessageType, parsed.Data);
+          if (parsed.MessageType === "ForceKeepAlive") {
+            this.sendKeepAlive();
+          }
+        }
+      } catch (e) {
+        this.emit("rawMessage", event.data);
+      }
+    };
   }
-  clear() {
-    this.store.clear();
+  startKeepAlive() {
+    this.stopKeepAlive();
+    const interval = this.options.keepAliveIntervalMs || 3e4;
+    if (interval > 0) {
+      this.keepAliveTimer = setInterval(() => {
+        if (this.isConnected) {
+          try {
+            this.sendKeepAlive();
+          } catch {
+          }
+        }
+      }, interval);
+    }
   }
-};
-var LocalStorageAdapter = class {
-  getItem(key) {
-    if (typeof localStorage !== "undefined") {
-      return localStorage.getItem(key);
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
     }
-    return null;
   }
-  setItem(key, value) {
-    if (typeof localStorage !== "undefined") {
-      localStorage.setItem(key, value);
+  scheduleReconnect() {
+    const maxAttempts = this.options.maxReconnectAttempts ?? 10;
+    if (this.reconnectAttempts >= maxAttempts) {
+      return;
     }
+    const interval = this.options.reconnectIntervalMs ?? 5e3;
+    const backoffDelay = Math.min(interval * Math.pow(1.5, this.reconnectAttempts), 6e4);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      if (!this.explicitlyClosed) {
+        try {
+          this.connect(this.options);
+        } catch (e) {
+          this.emit("error", e);
+        }
+      }
+    }, backoffDelay);
   }
-  removeItem(key) {
-    if (typeof localStorage !== "undefined") {
-      localStorage.removeItem(key);
+  cleanup() {
+    this.stopKeepAlive();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.onopen = null;
+        this.ws.onclose = null;
+        this.ws.onerror = null;
+        this.ws.onmessage = null;
+        if (this.ws.readyState === 0 || this.ws.readyState === 1) {
+          this.ws.close();
+        }
+      } catch {
+      }
+      this.ws = null;
     }
   }
 };
-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/sessions.ts
+var SessionsModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  /**
+   * Query active client sessions across the Jellyfin server via GET /Sessions.
+   */
+  async getSessions(options = {}) {
+    const params = {};
+    if (options.controllableByUserId) {
+      params.ControllableByUserId = options.controllableByUserId;
+    }
+    if (options.deviceId) {
+      params.DeviceId = options.deviceId;
+    }
+    if (options.activeWithinSeconds !== void 0) {
+      params.ActiveWithinSeconds = options.activeWithinSeconds;
+    }
+    const result = await this.http.request("/Sessions", { params });
+    return Array.isArray(result) ? result : [];
+  }
+  /**
+   * Instruct a remote session to start playback of specified items via POST /Sessions/{sessionId}/Playing.
+   *
+   * @param sessionId The target session ID.
+   * @param itemIds Single item ID or array of item IDs to play.
+   * @param options Additional playback parameters (command type, start ticks, etc.).
+   */
+  async play(sessionId, itemIds, options = {}) {
+    if (!sessionId) {
+      throw new JellyfinError("sessionId is required to send a play command.");
+    }
+    const ids = Array.isArray(itemIds) ? itemIds : [itemIds];
+    if (ids.length === 0) {
+      throw new JellyfinError("At least one itemId is required to send a play command.");
+    }
+    const params = {
+      ItemIds: ids.join(","),
+      PlayCommand: options.playCommand || "PlayNow"
+    };
+    if (options.startPositionTicks !== void 0) {
+      params.StartPositionTicks = options.startPositionTicks;
+    }
+    if (options.mediaSourceId) {
+      params.MediaSourceId = options.mediaSourceId;
+    }
+    if (options.audioStreamIndex !== void 0) {
+      params.AudioStreamIndex = options.audioStreamIndex;
+    }
+    if (options.subtitleStreamIndex !== void 0) {
+      params.SubtitleStreamIndex = options.subtitleStreamIndex;
+    }
+    if (options.startIndex !== void 0) {
+      params.StartIndex = options.startIndex;
+    }
+    await this.http.request(`/Sessions/${sessionId}/Playing`, {
+      method: "POST",
+      params
+    });
+  }
+  /**
+   * Send a playback control command to a remote session via POST /Sessions/{sessionId}/Playing/{command}.
+   */
+  async sendPlaystateCommand(sessionId, command, params = {}) {
+    if (!sessionId) {
+      throw new JellyfinError("sessionId is required to send a playstate command.");
+    }
+    await this.http.request(`/Sessions/${sessionId}/Playing/${command}`, {
+      method: "POST",
+      params
+    });
+  }
+  /**
+   * Toggle play / pause on a remote session.
+   */
+  async playPause(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "PlayPause");
+  }
+  /**
+   * Pause playback on a remote session.
+   */
+  async pause(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "Pause");
+  }
+  /**
+   * Resume playback on a remote session.
+   */
+  async unpause(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "Unpause");
+  }
+  /**
+   * Stop playback on a remote session.
+   */
+  async stop(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "Stop");
+  }
+  /**
+   * Seek to a specific tick position on a remote session.
+   *
+   * @param sessionId Target session ID.
+   * @param positionTicks Position in ticks (1 tick = 10,000 milliseconds = 100 nanoseconds).
+   */
+  async seek(sessionId, positionTicks) {
+    return await this.sendPlaystateCommand(sessionId, "Seek", {
+      SeekPositionTicks: positionTicks
+    });
+  }
+  /**
+   * Skip to the next track on a remote session.
+   */
+  async nextTrack(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "NextTrack");
+  }
+  /**
+   * Skip to the previous track on a remote session.
+   */
+  async previousTrack(sessionId) {
+    return await this.sendPlaystateCommand(sessionId, "PreviousTrack");
+  }
+  /**
+   * Send a general command to a remote session via POST /Sessions/{sessionId}/Command.
+   */
+  async sendGeneralCommand(sessionId, command) {
+    if (!sessionId) {
+      throw new JellyfinError("sessionId is required to send a general command.");
+    }
+    await this.http.request(`/Sessions/${sessionId}/Command`, {
+      method: "POST",
+      body: {
+        Name: command.Name,
+        Arguments: command.Arguments || {}
+      }
+    });
+  }
+  /**
+   * Set volume level on a remote session (0-100).
+   */
+  async setVolume(sessionId, volume) {
+    const clamped = Math.max(0, Math.min(100, Math.round(volume)));
+    return await this.sendGeneralCommand(sessionId, {
+      Name: "SetVolume",
+      Arguments: { Volume: String(clamped) }
+    });
+  }
+  /**
+   * Mute audio on a remote session.
+   */
+  async mute(sessionId) {
+    return await this.sendGeneralCommand(sessionId, { Name: "Mute" });
+  }
+  /**
+   * Unmute audio on a remote session.
+   */
+  async unmute(sessionId) {
+    return await this.sendGeneralCommand(sessionId, { Name: "Unmute" });
+  }
+  /**
+   * Toggle mute on a remote session.
+   */
+  async toggleMute(sessionId) {
+    return await this.sendGeneralCommand(sessionId, { Name: "ToggleMute" });
+  }
+  /**
+   * Switch the audio stream index on a remote session.
+   */
+  async setAudioStreamIndex(sessionId, index) {
+    return await this.sendGeneralCommand(sessionId, {
+      Name: "SetAudioStreamIndex",
+      Arguments: { Index: String(index) }
+    });
+  }
+  /**
+   * Switch the subtitle stream index on a remote session.
+   */
+  async setSubtitleStreamIndex(sessionId, index) {
+    return await this.sendGeneralCommand(sessionId, {
+      Name: "SetSubtitleStreamIndex",
+      Arguments: { Index: String(index) }
+    });
+  }
+  /**
+   * Display an on-screen dialog message modal on a remote session via POST /Sessions/{sessionId}/Message.
+   */
+  async sendMessage(sessionId, options) {
+    if (!sessionId) {
+      throw new JellyfinError("sessionId is required to send a message.");
+    }
+    const payload = typeof options === "string" ? { Text: options, Header: "Message" } : {
+      Text: options.text,
+      Header: options.header || "Message",
+      TimeoutMs: options.timeoutMs
+    };
+    await this.http.request(`/Sessions/${sessionId}/Message`, {
+      method: "POST",
+      body: payload
+    });
+  }
+  /**
+   * Instruct a remote session to navigate and view an item or page via POST /Sessions/{sessionId}/Viewing.
+   */
+  async viewItem(sessionId, itemType, itemId, itemName) {
+    if (!sessionId) {
+      throw new JellyfinError("sessionId is required to instruct session navigation.");
+    }
+    await this.http.request(`/Sessions/${sessionId}/Viewing`, {
+      method: "POST",
+      params: {
+        ItemType: itemType,
+        ItemId: itemId,
+        ItemName: itemName
+      }
+    });
+  }
+};
+
+// src/quick-connect.ts
+var QuickConnectModule = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Check whether Quick Connect is enabled on the connected Jellyfin server.
+   */
+  async isEnabled() {
+    try {
+      const result = await this.http.request("/QuickConnect/Enabled");
+      if (typeof result === "boolean") {
+        return result;
+      }
+      return String(result).toLowerCase() === "true";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Initiate a Quick Connect authentication session.
+   * Typically called by a client device (e.g. Smart TV or CLI) to generate a user-facing pairing code.
+   */
+  async initiate() {
+    const result = await this.http.request("/QuickConnect/Initiate", {
+      method: "POST"
+    });
+    if (!result || !result.Code || !result.Secret) {
+      throw new JellyfinError("Quick Connect initiate failed: Invalid server response.");
+    }
+    return result;
+  }
+  /**
+   * Check the current authorization status of an initiated Quick Connect secret.
+   *
+   * @param secret The secret token returned from initiate().
+   */
+  async check(secret) {
+    if (!secret) {
+      throw new JellyfinError("secret is required to check Quick Connect status.");
+    }
+    return await this.http.request("/QuickConnect/Connect", {
+      method: "GET",
+      params: { secret }
+    });
+  }
+  /**
+   * Authorize a Quick Connect pairing code from an authenticated session.
+   * Typically called on a mobile app or browser where the user is already logged in.
+   *
+   * @param code The pairing code shown on the target device.
+   * @param userId Optional specific user ID to authenticate as (defaults to the currently authenticated user).
+   */
+  async authorize(code, userId) {
+    if (!code) {
+      throw new JellyfinError("code is required to authorize Quick Connect.");
+    }
+    const params = {
+      Code: code.replace(/\s+/g, "")
+      // Normalize code by removing spaces
+    };
+    if (userId) {
+      params.UserId = userId;
+    }
+    await this.http.request("/QuickConnect/Authorize", {
+      method: "POST",
+      params
+    });
+    return true;
+  }
+  /**
+   * Repeatedly poll until the user authorizes the Quick Connect request or a timeout occurs.
+   *
+   * @param secret The secret token returned from initiate().
+   * @param options Polling configuration (intervalMs, timeoutMs, signal).
+   */
+  async poll(secret, options = {}) {
+    const { intervalMs = 2e3, timeoutMs = 18e4, signal } = options;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      if (signal?.aborted) {
+        throw new JellyfinError("Quick Connect polling was aborted.");
+      }
+      const state = await this.check(secret);
+      if (state.Authenticated) {
+        return state;
+      }
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => resolve(), intervalMs);
+        if (signal) {
+          signal.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timer);
+              reject(new JellyfinError("Quick Connect polling was aborted."));
+            },
+            { once: true }
+          );
+        }
+      });
+    }
+    throw new JellyfinError(`Quick Connect timed out after ${timeoutMs}ms.`);
+  }
+};
+
+// src/trickplay.ts
+var TrickplayModule = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Generates the HLS playlist URL for trickplay scrubbing image tiles.
+   * E.g. /Videos/{itemId}/Trickplay/{width}/tiles.m3u8
+   */
+  getTilesHlsUrl(itemId, width, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const { mediaSourceId, useQueryToken = true } = options;
+    const url = new URL(`${serverUrl}/Videos/${itemId}/Trickplay/${width}/tiles.m3u8`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
+    if (mediaSourceId) {
+      url.searchParams.append("MediaSourceId", mediaSourceId);
+    }
+    return url.toString();
+  }
+  /**
+   * Generates the URL for a specific trickplay thumbnail tile image sheet.
+   * E.g. /Videos/{itemId}/Trickplay/{width}/{index}.jpg
+   */
+  getTileImageUrl(itemId, width, index, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const { mediaSourceId, useQueryToken = true } = options;
+    const url = new URL(`${serverUrl}/Videos/${itemId}/Trickplay/${width}/${index}.jpg`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
+    if (mediaSourceId) {
+      url.searchParams.append("MediaSourceId", mediaSourceId);
+    }
+    return url.toString();
+  }
+  /**
+   * Fetches and parses the HLS trickplay manifest (tiles.m3u8) for the given item and resolution.
+   */
+  async getTrickplayManifest(itemId, width, options = {}) {
+    const params = {};
+    if (options.mediaSourceId) {
+      params.MediaSourceId = options.mediaSourceId;
+    }
+    const endpoint = `/Videos/${itemId}/Trickplay/${width}/tiles.m3u8`;
+    const rawM3u8 = await this.http.requestText(endpoint, { params });
+    const tiles = this.parseTilesM3u8(itemId, width, rawM3u8, options.mediaSourceId, options.useQueryToken);
+    return {
+      width,
+      rawM3u8,
+      tiles
+    };
+  }
+  /**
+   * Helper to parse #EXTINF and tile file names from a tiles.m3u8 playlist.
+   */
+  parseTilesM3u8(itemId, width, rawM3u8, mediaSourceId, useQueryToken = true) {
+    const lines = rawM3u8.split(/\r?\n/);
+    const tiles = [];
+    let currentDurationMs = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("#EXTINF:")) {
+        const secondsStr = trimmed.substring(8).split(",")[0];
+        const seconds = parseFloat(secondsStr);
+        currentDurationMs = !isNaN(seconds) ? Math.round(seconds * 1e3) : 0;
+      } else if (!trimmed.startsWith("#")) {
+        const indexMatch = trimmed.match(/^(\d+)\.(jpg|jpeg|png|webp)/i);
+        const index = indexMatch ? parseInt(indexMatch[1], 10) : tiles.length;
+        const url = this.getTileImageUrl(itemId, width, index, { mediaSourceId, useQueryToken });
+        tiles.push({
+          index,
+          durationMs: currentDurationMs,
+          url
+        });
+      }
+    }
+    return tiles;
+  }
+  /**
+   * Extracts the available trickplay thumbnail widths from a BaseItemDto's Trickplay metadata.
+   */
+  getAvailableResolutions(item, mediaSourceId) {
+    if (!item.Trickplay) {
+      return [];
+    }
+    const targetMediaSourceId = mediaSourceId || item.MediaSources && item.MediaSources[0]?.Id || Object.keys(item.Trickplay)[0];
+    if (!targetMediaSourceId || !item.Trickplay[targetMediaSourceId]) {
+      return [];
+    }
+    const sourceTrickplay = item.Trickplay[targetMediaSourceId];
+    return Object.keys(sourceTrickplay).map((w) => parseInt(w, 10)).filter((w) => !isNaN(w)).sort((a, b) => a - b);
+  }
+  /**
+   * Retrieves the TrickplayInfoDto metadata for a specified item and optional width.
+   */
+  getTrickplayInfo(item, width, mediaSourceId) {
+    if (!item.Trickplay) {
+      return null;
+    }
+    const targetMediaSourceId = mediaSourceId || item.MediaSources && item.MediaSources[0]?.Id || Object.keys(item.Trickplay)[0];
+    if (!targetMediaSourceId || !item.Trickplay[targetMediaSourceId]) {
+      return null;
+    }
+    const sourceTrickplay = item.Trickplay[targetMediaSourceId];
+    if (width !== void 0 && sourceTrickplay[String(width)]) {
+      return sourceTrickplay[String(width)];
+    }
+    const availableWidths = Object.keys(sourceTrickplay);
+    if (availableWidths.length === 0) {
+      return null;
+    }
+    return sourceTrickplay[availableWidths[0]];
+  }
+  /**
+   * Calculates the exact tile sheet index, image URL, and sprite coordinates (x, y, width, height)
+   * for a given playback timestamp to render scrubbing thumbnails in a player or seekbar UI.
+   */
+  getThumbnailForTimestamp(options) {
+    const {
+      item,
+      timestampMs,
+      timestampTicks,
+      width,
+      mediaSourceId,
+      useQueryToken = true
+    } = options;
+    let info = options.trickplayInfo;
+    if (!info && item) {
+      info = this.getTrickplayInfo(item, width, mediaSourceId) || void 0;
+    }
+    if (!info) {
+      return null;
+    }
+    const timeMs = timestampMs !== void 0 ? timestampMs : timestampTicks !== void 0 ? Math.round(timestampTicks / 1e4) : 0;
+    const interval = info.Interval > 0 ? info.Interval : 1e4;
+    let thumbIndex = Math.floor(Math.max(0, timeMs) / interval);
+    if (info.ThumbnailCount > 0 && thumbIndex >= info.ThumbnailCount) {
+      thumbIndex = info.ThumbnailCount - 1;
+    }
+    const tileCols = info.TileWidth > 0 ? info.TileWidth : 1;
+    const tileRows = info.TileHeight > 0 ? info.TileHeight : 1;
+    const thumbsPerSheet = tileCols * tileRows;
+    const sheetIndex = Math.floor(thumbIndex / thumbsPerSheet);
+    const indexInSheet = thumbIndex % thumbsPerSheet;
+    const col = indexInSheet % tileCols;
+    const row = Math.floor(indexInSheet / tileCols);
+    const x = col * info.Width;
+    const y = row * info.Height;
+    const itemId = item?.Id || "";
+    if (!itemId) {
+      throw new JellyfinError("Item or itemId is required to generate the thumbnail URL.");
+    }
+    const imageUrl = this.getTileImageUrl(itemId, info.Width, sheetIndex, {
+      mediaSourceId,
+      useQueryToken
+    });
+    return {
+      tileIndex: sheetIndex,
+      imageUrl,
+      x,
+      y,
+      width: info.Width,
+      height: info.Height,
+      thumbnailIndex: thumbIndex
+    };
+  }
+};
+
+// src/chapters.ts
+var ChaptersModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  /**
+   * Synchronously extracts chapter markers from an already fetched BaseItemDto.
+   */
+  extractChapters(item) {
+    return item.Chapters || [];
+  }
+  /**
+   * Fetches the chapter markers for an item from the server.
+   */
+  async getChapters(itemId) {
+    const userId = this.getUserId ? this.getUserId() : "";
+    const endpoint = userId ? `/Users/${userId}/Items/${itemId}` : `/Items/${itemId}`;
+    const item = await this.http.request(endpoint, {
+      params: {
+        Fields: "Chapters"
+      }
+    });
+    return item.Chapters || [];
+  }
+  /**
+   * Generates the URL for a chapter preview thumbnail image.
+   * E.g. /Items/{itemId}/Images/Chapter/{chapterIndex}
+   */
+  getChapterImageUrl(itemId, chapterIndex, options = {}) {
+    const serverUrl = this.http.getServerUrl();
+    const token = this.http.getToken();
+    const {
+      maxWidth,
+      maxHeight,
+      width,
+      height,
+      quality,
+      format,
+      tag,
+      fillWidth,
+      fillHeight,
+      useQueryToken = true
+    } = options;
+    const url = new URL(`${serverUrl}/Items/${itemId}/Images/Chapter/${chapterIndex}`);
+    if (token && useQueryToken) {
+      url.searchParams.append("api_key", token);
+      url.searchParams.append("X-Emby-Token", token);
+    }
+    if (tag) url.searchParams.append("tag", tag);
+    if (maxWidth) url.searchParams.append("maxWidth", String(maxWidth));
+    if (maxHeight) url.searchParams.append("maxHeight", String(maxHeight));
+    if (width) url.searchParams.append("width", String(width));
+    if (height) url.searchParams.append("height", String(height));
+    if (quality) url.searchParams.append("quality", String(quality));
+    if (format) url.searchParams.append("format", format);
+    if (fillWidth) url.searchParams.append("fillWidth", String(fillWidth));
+    if (fillHeight) url.searchParams.append("fillHeight", String(fillHeight));
+    return url.toString();
+  }
+  /**
+   * Retrieves media segments (Intro, Outro, Recap, Commercials) for an item via Jellyfin 10.10+ /MediaSegments.
+   */
+  async getMediaSegments(itemId, options = {}) {
+    const params = {
+      itemId
+    };
+    if (options.includeSegmentTypes && options.includeSegmentTypes.length > 0) {
+      params.includeSegmentTypes = options.includeSegmentTypes.join(",");
+    }
+    try {
+      const res = await this.http.request(
+        "/MediaSegments",
+        { params }
+      );
+      if (Array.isArray(res)) {
+        return res;
+      }
+      if (res && Array.isArray(res.Items)) {
+        return res.Items;
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Resolves intro and end credits markers for an item, combining /MediaSegments API
+   * and chapter marker heuristics (MarkerType or naming like 'Intro', 'Opening', 'Credits', 'Ending').
+   */
+  async getIntroCredits(itemOrChaptersOrId, mediaSegments) {
+    let itemId = "";
+    let chapters = [];
+    let segments = mediaSegments || [];
+    if (typeof itemOrChaptersOrId === "string") {
+      itemId = itemOrChaptersOrId;
+      if (segments.length === 0) {
+        segments = await this.getMediaSegments(itemId);
+      }
+      if (segments.length === 0) {
+        chapters = await this.getChapters(itemId);
+      }
+    } else if (Array.isArray(itemOrChaptersOrId)) {
+      chapters = itemOrChaptersOrId;
+    } else if (typeof itemOrChaptersOrId === "object" && itemOrChaptersOrId !== null) {
+      itemId = itemOrChaptersOrId.Id;
+      chapters = itemOrChaptersOrId.Chapters || [];
+      if (segments.length === 0 && itemId) {
+        segments = await this.getMediaSegments(itemId);
+      }
+    }
+    const markers = {
+      segments
+    };
+    for (const seg of segments) {
+      const type = String(seg.Type).toLowerCase();
+      if (type === "intro" && !markers.intro) {
+        markers.intro = {
+          startTicks: seg.StartTicks,
+          endTicks: seg.EndTicks,
+          startMs: Math.round(seg.StartTicks / 1e4),
+          endMs: Math.round(seg.EndTicks / 1e4)
+        };
+      } else if ((type === "outro" || type === "credits") && !markers.credits) {
+        markers.credits = {
+          startTicks: seg.StartTicks,
+          endTicks: seg.EndTicks,
+          startMs: Math.round(seg.StartTicks / 1e4),
+          endMs: Math.round(seg.EndTicks / 1e4)
+        };
+      }
+    }
+    if ((!markers.intro || !markers.credits) && chapters.length > 0) {
+      for (let i = 0; i < chapters.length; i++) {
+        const chapter = chapters[i];
+        const nextChapter = chapters[i + 1];
+        const name = (chapter.Name || "").trim();
+        const markerType = (chapter.MarkerType || "").toLowerCase();
+        if (!markers.intro) {
+          if (markerType === "introstart" || /^(intro|opening|theme\s*song)/i.test(name)) {
+            const startTicks = chapter.StartPositionTicks;
+            const endTicks = nextChapter ? nextChapter.StartPositionTicks : startTicks + 90 * 1e7;
+            markers.intro = {
+              startTicks,
+              endTicks,
+              startMs: Math.round(startTicks / 1e4),
+              endMs: Math.round(endTicks / 1e4)
+            };
+          }
+        }
+        if (!markers.credits) {
+          if (markerType === "creditsstart" || /^(credits|outro|ending|end\s*credits)/i.test(name)) {
+            const startTicks = chapter.StartPositionTicks;
+            const endTicks = nextChapter ? nextChapter.StartPositionTicks : startTicks + 180 * 1e7;
+            markers.credits = {
+              startTicks,
+              endTicks,
+              startMs: Math.round(startTicks / 1e4),
+              endMs: Math.round(endTicks / 1e4)
+            };
+          }
+        }
+      }
+    }
+    return markers;
+  }
+  /**
+   * Checks whether the current playback position falls within an intro or credits range.
+   */
+  findCurrentSegment(positionTicks, markersOrSegments) {
+    if (Array.isArray(markersOrSegments)) {
+      for (const seg of markersOrSegments) {
+        if (positionTicks >= seg.StartTicks && positionTicks < seg.EndTicks) {
+          return {
+            type: seg.Type,
+            startTicks: seg.StartTicks,
+            endTicks: seg.EndTicks
+          };
+        }
+      }
+      return null;
+    }
+    const { intro, credits } = markersOrSegments;
+    if (intro && positionTicks >= intro.startTicks && positionTicks < intro.endTicks) {
+      return {
+        type: "Intro",
+        startTicks: intro.startTicks,
+        endTicks: intro.endTicks
+      };
+    }
+    if (credits && positionTicks >= credits.startTicks && positionTicks < credits.endTicks) {
+      return {
+        type: "Credits",
+        startTicks: credits.startTicks,
+        endTicks: credits.endTicks
+      };
+    }
+    return null;
+  }
+  /**
+   * Returns the timestamp ticks to skip to if the current position is within a skippable segment,
+   * or null if not currently within any skippable range.
+   */
+  getSkipPosition(positionTicks, markersOrSegments) {
+    const current = this.findCurrentSegment(positionTicks, markersOrSegments);
+    return current ? current.endTicks : null;
+  }
+};
+
+// src/genres.ts
+var GenresModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  resolveUserId(explicitUserId) {
+    return explicitUserId || this.getUserId() || "";
+  }
+  /**
+   * Retrieves video/movie genres from the server via GET /Genres.
+   */
+  async getGenres(options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    if (options.parentId) params.ParentId = options.parentId;
+    if (options.startIndex !== void 0) params.StartIndex = options.startIndex;
+    if (options.limit !== void 0) params.Limit = options.limit;
+    if (options.searchTerm) params.SearchTerm = options.searchTerm;
+    if (options.sortBy) params.SortBy = options.sortBy;
+    if (options.sortOrder) params.SortOrder = options.sortOrder;
+    if (options.enableImages !== void 0) params.EnableImages = options.enableImages;
+    if (options.imageTypeLimit !== void 0) params.ImageTypeLimit = options.imageTypeLimit;
+    if (options.enableImageTypes && options.enableImageTypes.length > 0) {
+      params.EnableImageTypes = options.enableImageTypes.join(",");
+    }
+    return await this.http.request("/Genres", { params });
+  }
+  /**
+   * Retrieves a single genre by name via GET /Genres/{genreName}.
+   */
+  async getGenre(genreName, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    return await this.http.request(`/Genres/${encodeURIComponent(genreName)}`, {
+      params
+    });
+  }
+  /**
+   * Retrieves music genres from the server via GET /MusicGenres.
+   */
+  async getMusicGenres(options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    if (options.parentId) params.ParentId = options.parentId;
+    if (options.startIndex !== void 0) params.StartIndex = options.startIndex;
+    if (options.limit !== void 0) params.Limit = options.limit;
+    if (options.searchTerm) params.SearchTerm = options.searchTerm;
+    if (options.sortBy) params.SortBy = options.sortBy;
+    if (options.sortOrder) params.SortOrder = options.sortOrder;
+    if (options.enableImages !== void 0) params.EnableImages = options.enableImages;
+    if (options.imageTypeLimit !== void 0) params.ImageTypeLimit = options.imageTypeLimit;
+    if (options.enableImageTypes && options.enableImageTypes.length > 0) {
+      params.EnableImageTypes = options.enableImageTypes.join(",");
+    }
+    return await this.http.request("/MusicGenres", { params });
+  }
+  /**
+   * Retrieves a single music genre by name via GET /MusicGenres/{genreName}.
+   */
+  async getMusicGenre(genreName, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    return await this.http.request(`/MusicGenres/${encodeURIComponent(genreName)}`, {
+      params
+    });
+  }
+  /**
+   * Retrieves studios/production companies from the server via GET /Studios.
+   */
+  async getStudios(options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    if (options.parentId) params.ParentId = options.parentId;
+    if (options.startIndex !== void 0) params.StartIndex = options.startIndex;
+    if (options.limit !== void 0) params.Limit = options.limit;
+    if (options.searchTerm) params.SearchTerm = options.searchTerm;
+    if (options.sortBy) params.SortBy = options.sortBy;
+    if (options.sortOrder) params.SortOrder = options.sortOrder;
+    if (options.enableImages !== void 0) params.EnableImages = options.enableImages;
+    if (options.imageTypeLimit !== void 0) params.ImageTypeLimit = options.imageTypeLimit;
+    if (options.enableImageTypes && options.enableImageTypes.length > 0) {
+      params.EnableImageTypes = options.enableImageTypes.join(",");
+    }
+    return await this.http.request("/Studios", { params });
+  }
+  /**
+   * Retrieves a single studio by name via GET /Studios/{studioName}.
+   */
+  async getStudio(studioName, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    return await this.http.request(`/Studios/${encodeURIComponent(studioName)}`, {
+      params
+    });
+  }
+};
+
+// src/collections.ts
+var CollectionsModule = class {
+  http;
+  getUserId;
+  constructor(http, getUserId) {
+    this.http = http;
+    this.getUserId = getUserId;
+  }
+  resolveUserId(explicitUserId) {
+    return explicitUserId || this.getUserId() || "";
+  }
+  /**
+   * Retrieves user BoxSet / Collections via GET /Collections.
+   */
+  async getCollections(options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const params = {};
+    if (userId) params.UserId = userId;
+    if (options.parentId) params.ParentId = options.parentId;
+    if (options.startIndex !== void 0) params.StartIndex = options.startIndex;
+    if (options.limit !== void 0) params.Limit = options.limit;
+    if (options.searchTerm) params.SearchTerm = options.searchTerm;
+    if (options.sortBy) params.SortBy = options.sortBy;
+    if (options.sortOrder) params.SortOrder = options.sortOrder;
+    if (options.enableImages !== void 0) params.EnableImages = options.enableImages;
+    if (options.imageTypeLimit !== void 0) params.ImageTypeLimit = options.imageTypeLimit;
+    if (options.enableImageTypes && options.enableImageTypes.length > 0) {
+      params.EnableImageTypes = options.enableImageTypes.join(",");
+    }
+    return await this.http.request("/Collections", { params });
+  }
+  /**
+   * Retrieves the items belonging to a collection / BoxSet.
+   */
+  async getCollectionItems(collectionId, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const endpoint = userId ? `/Users/${userId}/Items` : "/Items";
+    const params = {
+      ParentId: collectionId
+    };
+    if (options.startIndex !== void 0) params.StartIndex = options.startIndex;
+    if (options.limit !== void 0) params.Limit = options.limit;
+    if (options.fields) params.Fields = options.fields;
+    if (options.sortBy) params.SortBy = options.sortBy;
+    if (options.sortOrder) params.SortOrder = options.sortOrder;
+    return await this.http.request(endpoint, { params });
+  }
+  /**
+   * Creates a new BoxSet / Collection via POST /Collections.
+   */
+  async createCollection(options) {
+    const params = {
+      Name: options.name
+    };
+    if (options.ids && options.ids.length > 0) {
+      params.Ids = options.ids.join(",");
+    }
+    if (options.parentId) {
+      params.ParentId = options.parentId;
+    }
+    if (options.isFolder !== void 0) {
+      params.IsFolder = options.isFolder;
+    }
+    return await this.http.request("/Collections", {
+      method: "POST",
+      params
+    });
+  }
+  /**
+   * Adds items to an existing BoxSet / Collection via POST /Collections/{collectionId}/Items.
+   */
+  async addToCollection(collectionId, itemIds) {
+    const ids = Array.isArray(itemIds) ? itemIds.join(",") : itemIds;
+    await this.http.request(`/Collections/${collectionId}/Items`, {
+      method: "POST",
+      params: {
+        Ids: ids
+      }
+    });
+  }
+  /**
+   * Removes items from an existing BoxSet / Collection via DELETE /Collections/{collectionId}/Items.
+   */
+  async removeFromCollection(collectionId, itemIds) {
+    const ids = Array.isArray(itemIds) ? itemIds.join(",") : itemIds;
+    await this.http.request(`/Collections/${collectionId}/Items`, {
+      method: "DELETE",
+      params: {
+        Ids: ids
+      }
+    });
+  }
+};
+
+// src/display-preferences.ts
+var DisplayPreferencesModule = class {
+  http;
+  getUserId;
+  defaultClient;
+  constructor(http, getUserId, defaultClient = "emby") {
+    this.http = http;
+    this.getUserId = getUserId;
+    this.defaultClient = defaultClient;
+  }
+  resolveUserId(explicitUserId) {
+    const userId = explicitUserId || this.getUserId();
+    if (!userId) {
+      throw new JellyfinError(
+        "User ID is required for DisplayPreferences. Please authenticate or specify userId."
+      );
+    }
+    return userId;
+  }
+  /**
+   * Retrieves the user's display preferences for a specific folder or view.
+   * GET /DisplayPreferences/{displayPreferencesId}
+   */
+  async getDisplayPreferences(displayPreferencesId, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const client = options.client || this.defaultClient;
+    return await this.http.request(
+      `/DisplayPreferences/${displayPreferencesId}`,
+      {
+        params: {
+          userId,
+          client
+        }
+      }
+    );
+  }
+  /**
+   * Updates display preferences for a specific folder or view.
+   * POST /DisplayPreferences/{displayPreferencesId}
+   */
+  async updateDisplayPreferences(displayPreferencesId, preferences, options = {}) {
+    const userId = this.resolveUserId(options.userId);
+    const client = options.client || this.defaultClient;
+    const payload = {
+      ...preferences,
+      Id: preferences.Id || displayPreferencesId,
+      Client: preferences.Client || client
+    };
+    await this.http.request(`/DisplayPreferences/${displayPreferencesId}`, {
+      method: "POST",
+      params: {
+        userId,
+        client
+      },
+      body: payload
+    });
+  }
+  /**
+   * Sets a custom client-specific key-value pair in CustomPrefs.
+   */
+  async setCustomPreference(displayPreferencesId, key, value, options = {}) {
+    const current = await this.getDisplayPreferences(displayPreferencesId, options);
+    const customPrefs = {
+      ...current.CustomPrefs || {},
+      [key]: value
+    };
+    const updated = {
+      ...current,
+      CustomPrefs: customPrefs
+    };
+    await this.updateDisplayPreferences(displayPreferencesId, updated, options);
+    return updated;
+  }
+  /**
+   * Updates sort field and order preferences for a view.
+   */
+  async setSortPreferences(displayPreferencesId, sortBy, sortOrder, options = {}) {
+    const current = await this.getDisplayPreferences(displayPreferencesId, options);
+    const updated = {
+      ...current,
+      SortBy: sortBy,
+      SortOrder: sortOrder,
+      RememberSorting: true
+    };
+    await this.updateDisplayPreferences(displayPreferencesId, updated, options);
+    return updated;
+  }
+  /**
+   * Sets the view presentation layout type (e.g. 'Poster', 'Thumb', 'Banner', 'List').
+   */
+  async setViewType(displayPreferencesId, viewType, options = {}) {
+    const current = await this.getDisplayPreferences(displayPreferencesId, options);
+    const updated = {
+      ...current,
+      ViewType: viewType
+    };
+    await this.updateDisplayPreferences(displayPreferencesId, updated, options);
+    return updated;
+  }
+};
+
+// 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 {
@@ -2421,6 +3731,14 @@ var JellyfinClient = class {
   nextUp;
   latest;
   transcode;
+  websocket;
+  sessions;
+  quickConnect;
+  trickplay;
+  chapters;
+  genres;
+  collections;
+  displayPreferences;
   http;
   storage;
   cache;
@@ -2431,7 +3749,7 @@ var JellyfinClient = class {
     this.cache = new MemoryCacheAdapter();
     this.clientInfo = {
       name: options.clientInfo?.name || "@francofantomius/jellyfin",
-      version: options.clientInfo?.version || "0.2.0",
+      version: options.clientInfo?.version || "0.4.0",
       device: options.clientInfo?.device || (typeof window !== "undefined" ? "Web Browser" : "Node.js"),
       deviceId: options.clientInfo?.deviceId || generateDeviceId()
     };
@@ -2466,6 +3784,14 @@ var JellyfinClient = class {
     this.nextUp = new NextUpModule(this.http, getUserId);
     this.latest = new LatestModule(this.http, getUserId);
     this.transcode = new TranscodeModule(this.http, getDeviceId);
+    this.websocket = new WebSocketModule(this.http, getDeviceId);
+    this.sessions = new SessionsModule(this.http, getUserId);
+    this.quickConnect = new QuickConnectModule(this.http);
+    this.trickplay = new TrickplayModule(this.http);
+    this.chapters = new ChaptersModule(this.http, getUserId);
+    this.genres = new GenresModule(this.http, getUserId);
+    this.collections = new CollectionsModule(this.http, getUserId);
+    this.displayPreferences = new DisplayPreferencesModule(this.http, getUserId, this.clientInfo.name);
   }
   // --- Configuration Getters & Setters ---
   get serverUrl() {
@@ -2567,6 +3893,9 @@ var JellyfinClient = class {
    * Log out and clear tokens and session.
    */
   logout() {
+    if (this.websocket.isConnected) {
+      this.websocket.disconnect();
+    }
     this.auth.logout();
     this.emit("logout");
   }
@@ -2585,7 +3914,11 @@ var JellyfinClient = class {
 exports.AUDIO_QUALITY_PRESETS = AUDIO_QUALITY_PRESETS;
 exports.AuthModule = AuthModule;
 exports.COMMON_SEARCH_FIELDS = COMMON_SEARCH_FIELDS;
+exports.ChaptersModule = ChaptersModule;
+exports.CollectionsModule = CollectionsModule;
+exports.DisplayPreferencesModule = DisplayPreferencesModule;
 exports.FavoritesModule = FavoritesModule;
+exports.GenresModule = GenresModule;
 exports.HttpTransport = HttpTransport;
 exports.IndexedDBCacheAdapter = IndexedDBCacheAdapter;
 exports.JellyfinApiError = JellyfinApiError;
@@ -2603,11 +3936,15 @@ exports.NextUpModule = NextUpModule;
 exports.OfflineStorageManager = OfflineStorageManager;
 exports.PlaybackModule = PlaybackModule;
 exports.PlaylistsModule = PlaylistsModule;
+exports.QuickConnectModule = QuickConnectModule;
 exports.ResumeModule = ResumeModule;
 exports.SearchModule = SearchModule;
+exports.SessionsModule = SessionsModule;
 exports.SystemModule = SystemModule;
 exports.TranscodeModule = TranscodeModule;
+exports.TrickplayModule = TrickplayModule;
 exports.VIDEO_QUALITY_PRESETS = VIDEO_QUALITY_PRESETS;
+exports.WebSocketModule = WebSocketModule;
 exports.buildAuthHeader = buildAuthHeader;
 exports.cleanUrl = cleanUrl;
 exports.fetchWithCache = fetchWithCache;