@harmoni-org/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2054 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var socket_ioClient = require('socket.io-client');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/errors/ApiError.ts
+var ApiError = class _ApiError extends Error {
+  constructor(message, status, code, details) {
+    super(message);
+    this.isApiError = true;
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ApiError);
+    }
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details
+    };
+  }
+  static isApiError(error) {
+    return error instanceof _ApiError || error?.isApiError === true;
+  }
+};
+var NetworkError = class extends ApiError {
+  constructor(message = "Network error occurred") {
+    super(message, 0, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends ApiError {
+  constructor(message = "Request timeout") {
+    super(message, 408, "TIMEOUT_ERROR");
+    this.name = "TimeoutError";
+  }
+};
+var UnauthorizedError = class extends ApiError {
+  constructor(message = "Unauthorized") {
+    super(message, 401, "UNAUTHORIZED");
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(message = "Forbidden") {
+    super(message, 403, "FORBIDDEN");
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "NOT_FOUND");
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends ApiError {
+  constructor(message = "Validation failed", details) {
+    super(message, 422, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+
+// src/core/http/HttpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.authToken = null;
+    this.retryCount = /* @__PURE__ */ new Map();
+    this.client = axios__default.default.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout || 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers
+      },
+      withCredentials: config.withCredentials || false
+    });
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.client.interceptors.request.use(
+      (config) => {
+        const requestConfig = config;
+        if (this.authToken && !requestConfig.skipAuth) {
+          config.headers = config.headers || {};
+          config.headers.Authorization = `Bearer ${this.authToken}`;
+        }
+        return config;
+      },
+      (error) => {
+        return Promise.reject(this.handleError(error));
+      }
+    );
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status === 401 && !originalRequest._retry && this.refreshTokenFn) {
+          originalRequest._retry = true;
+          try {
+            const newToken = await this.refreshTokenFn();
+            this.setAuthToken(newToken);
+            if (!originalRequest.headers) {
+              originalRequest.headers = {};
+            }
+            originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            return this.client.request(originalRequest);
+          } catch (refreshError) {
+            this.authToken = null;
+            return Promise.reject(this.handleError(refreshError));
+          }
+        }
+        if (this.shouldRetry(error, originalRequest)) {
+          return this.retryRequest(originalRequest);
+        }
+        return Promise.reject(this.handleError(error));
+      }
+    );
+  }
+  shouldRetry(error, config) {
+    if (!config || config.skipRetry) return false;
+    const retryConfig = this.config.retryConfig;
+    if (!retryConfig || !retryConfig.maxRetries) return false;
+    const method = config.method?.toUpperCase();
+    const safeToRetry = method === "GET" || method === "HEAD" || method === "OPTIONS";
+    if (!safeToRetry && !config._retry) {
+      return false;
+    }
+    const requestId = this.getRequestId(config);
+    const currentRetries = this.retryCount.get(requestId) || 0;
+    if (currentRetries >= retryConfig.maxRetries) {
+      this.retryCount.delete(requestId);
+      return false;
+    }
+    const retryableStatuses = retryConfig.retryableStatuses || [408, 429, 500, 502, 503, 504];
+    return error.response ? retryableStatuses.includes(error.response.status) : true;
+  }
+  async retryRequest(config) {
+    const requestId = this.getRequestId(config);
+    const currentRetries = this.retryCount.get(requestId) || 0;
+    this.retryCount.set(requestId, currentRetries + 1);
+    const delay = this.config.retryConfig?.retryDelay || 1e3;
+    const backoffDelay = delay * Math.pow(2, currentRetries);
+    await this.sleep(backoffDelay);
+    config._retryCount = currentRetries + 1;
+    return this.client.request(config);
+  }
+  getRequestId(config) {
+    return `${config.method}-${config.url}`;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  handleError(error) {
+    if (ApiError.isApiError(error)) {
+      return error;
+    }
+    if (axios__default.default.isAxiosError(error)) {
+      const axiosError = error;
+      if (!axiosError.response) {
+        if (axiosError.code === "ECONNABORTED") {
+          return new TimeoutError();
+        }
+        return new NetworkError(axiosError.message);
+      }
+      const status = axiosError.response.status;
+      const data = axiosError.response.data;
+      const message = data?.message || axiosError.message;
+      switch (status) {
+        case 401:
+          return new UnauthorizedError(message);
+        case 403:
+          return new ForbiddenError(message);
+        case 404:
+          return new NotFoundError(message);
+        case 422:
+          return new ValidationError(message, data);
+        default:
+          return new ApiError(message, status, data?.code, data);
+      }
+    }
+    return new ApiError(error instanceof Error ? error.message : "An unknown error occurred", 500);
+  }
+  // Public methods
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  getAuthToken() {
+    return this.authToken;
+  }
+  setRefreshTokenFunction(fn) {
+    this.refreshTokenFn = fn;
+  }
+  addRequestInterceptor(interceptor) {
+    return this.client.interceptors.request.use(
+      interceptor.onFulfilled,
+      interceptor.onRejected
+    );
+  }
+  addResponseInterceptor(interceptor) {
+    return this.client.interceptors.response.use(interceptor.onFulfilled, interceptor.onRejected);
+  }
+  removeRequestInterceptor(id) {
+    this.client.interceptors.request.eject(id);
+  }
+  removeResponseInterceptor(id) {
+    this.client.interceptors.response.eject(id);
+  }
+  // HTTP methods
+  async get(url, config) {
+    const response = await this.client.get(url, config);
+    return response.data;
+  }
+  async post(url, data, config) {
+    const requestConfig = { ...config };
+    if (data instanceof FormData) {
+      requestConfig.headers = {
+        ...requestConfig.headers,
+        "Content-Type": "multipart/form-data"
+      };
+    }
+    const response = await this.client.post(url, data, requestConfig);
+    return response.data;
+  }
+  async put(url, data, config) {
+    const requestConfig = { ...config };
+    if (data instanceof FormData) {
+      requestConfig.headers = {
+        ...requestConfig.headers,
+        "Content-Type": "multipart/form-data"
+      };
+    }
+    const response = await this.client.put(url, data, requestConfig);
+    return response.data;
+  }
+  async patch(url, data, config) {
+    const requestConfig = { ...config };
+    if (data instanceof FormData) {
+      requestConfig.headers = {
+        ...requestConfig.headers,
+        "Content-Type": "multipart/form-data"
+      };
+    }
+    const response = await this.client.patch(url, data, requestConfig);
+    return response.data;
+  }
+  async delete(url, config) {
+    const response = await this.client.delete(url, config);
+    return response.data;
+  }
+};
+
+// src/modules/auth/AuthModule.ts
+var AuthModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Authenticates the user by calling the login endpoint.
+   * @param credentials - The login request payload containing emailOrUsername and password.
+   * @returns The logged-in user information including the access token.
+   */
+  async login(credentials) {
+    const response = await this.http.post("/auth/login", credentials, {
+      skipAuth: true
+    });
+    const { user, accessToken, refreshToken } = response;
+    this.http.setAuthToken(accessToken);
+    const normalizedUser = {
+      ...user,
+      id: user.userId || user.id,
+      token: accessToken,
+      refreshToken
+    };
+    return normalizedUser;
+  }
+  /**
+   * Registers a new user by calling the registration endpoint.
+   * @param registrationData - The registration request payload containing username, password, and optionally email.
+   * @returns The newly created user information including the access token.
+   */
+  async register(data) {
+    const response = await this.http.post("/auth/register", data, {
+      skipAuth: true
+    });
+    const { user, accessToken, refreshToken } = response;
+    this.http.setAuthToken(accessToken);
+    const normalizedUser = {
+      ...user,
+      id: user.userId || user.id,
+      token: accessToken,
+      refreshToken
+    };
+    return normalizedUser;
+  }
+  /**
+   * Verifies if the provided JWT token is valid.
+   * @returns The user information if the token is valid.
+   */
+  async verifyToken() {
+    const response = await this.http.get("/auth/verify-token");
+    if (response.user && response.user.userId) {
+      response.user.id = response.user.userId;
+    }
+    return response;
+  }
+  /**
+   * Refreshes the access token using the stored refresh token.
+   * @returns The newly issued access token.
+   */
+  async refreshAccessToken() {
+    const response = await this.http.get("/auth/refresh-token");
+    const { accessToken } = response;
+    this.http.setAuthToken(accessToken);
+    return accessToken;
+  }
+  /**
+   * Checks if the provided email is unique (not already registered).
+   * @param email - The email address to check.
+   * @returns True if the email is unique, otherwise false.
+   */
+  async isEmailUnique(email) {
+    const response = await this.http.get(`/auth/check-email/${email}`, {
+      skipAuth: true
+    });
+    return response.isUnique;
+  }
+  /**
+   * Checks if the provided username is unique (not already taken).
+   * @param username - The username to check.
+   * @returns True if the username is unique, otherwise false.
+   */
+  async isUsernameUnique(username) {
+    const response = await this.http.get(
+      `/auth/check-username/${username}`,
+      { skipAuth: true }
+    );
+    return response.isUnique;
+  }
+  /**
+   * Logout the current user
+   */
+  async logout() {
+    this.http.setAuthToken(null);
+  }
+  /**
+   * Request password reset
+   */
+  async requestPasswordReset(email) {
+    await this.http.post("/auth/password/reset-request", { email }, { skipAuth: true });
+  }
+  /**
+   * Reset password with token
+   */
+  async resetPassword(token, newPassword) {
+    await this.http.post("/auth/password/reset", { token, newPassword }, { skipAuth: true });
+  }
+  /**
+   * Change password for authenticated user
+   */
+  async changePassword(currentPassword, newPassword) {
+    await this.http.post("/auth/password/change", {
+      currentPassword,
+      newPassword
+    });
+  }
+  /**
+   * Verify email with token
+   */
+  async verifyEmail(token) {
+    await this.http.post("/auth/email/verify", { token }, { skipAuth: true });
+  }
+  /**
+   * Resend verification email
+   */
+  async resendVerificationEmail(email) {
+    await this.http.post("/auth/email/resend", { email }, { skipAuth: true });
+  }
+};
+
+// src/modules/user/UserModule.ts
+var UserModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get user by ID
+   */
+  async getById(userId) {
+    return this.http.get(`/users/${userId}`);
+  }
+  /**
+   * Get current user profile
+   */
+  async getCurrentUser() {
+    return this.http.get("/users/me");
+  }
+  /**
+   * Update current user profile
+   */
+  async updateProfile(data) {
+    return this.http.patch("/users/me", data);
+  }
+  /**
+   * Delete current user account
+   */
+  async deleteAccount() {
+    await this.http.delete("/users/me");
+  }
+  /**
+   * Get list of users with pagination and filters
+   */
+  async list(params) {
+    return this.http.get("/users", { params });
+  }
+  /**
+   * Search users by query
+   */
+  async search(query, params) {
+    return this.http.get("/users/search", {
+      params: { query, ...params }
+    });
+  }
+  /**
+   * Upload user avatar
+   */
+  async uploadAvatar(file, fileName) {
+    const formData = new FormData();
+    formData.append("avatar", file, fileName);
+    return this.http.post("/users/me/avatar", formData);
+  }
+  /**
+   * Delete user avatar
+   */
+  async deleteAvatar() {
+    await this.http.delete("/users/me/avatar");
+  }
+};
+
+// src/modules/watchTogether/WatchTogetherError.ts
+var WatchTogetherError = class _WatchTogetherError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.isWatchTogetherError = true;
+    this.name = "WatchTogetherError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WatchTogetherError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+  static isWatchTogetherError(error) {
+    return error instanceof _WatchTogetherError || error?.isWatchTogetherError === true;
+  }
+};
+
+// src/types/actions.ts
+var USER_ACTIONS = {
+  // Core playback actions (synced with Watch Together)
+  PLAY: "PLAY",
+  PAUSE: "PAUSE",
+  SEEK: "SEEK",
+  // File/media actions
+  FILE_UPDATE: "FILE_UPDATE",
+  // Advanced actions (may not be synced)
+  STOP: "STOP",
+  VOLUME_UPDATE: "VOLUME_UPDATE",
+  ENTER_FULLSCREEN: "ENTER_FULLSCREEN",
+  EXIT_FULLSCREEN: "EXIT_FULLSCREEN",
+  SPEED_UPDATE: "SPEED_UPDATE",
+  AUDIO_DELAY_UPDATE: "AUDIO_DELAY_UPDATE",
+  SUBTITLE_DELAY_UPDATE: "SUBTITLE_DELAY_UPDATE",
+  ASPECT_RATIO_UPDATE: "ASPECT_RATIO_UPDATE",
+  TOGGLE_REPEAT: "TOGGLE_REPEAT",
+  TOGGLE_LOOP: "TOGGLE_LOOP",
+  VIDEO_EFFECT_UPDATE: "VIDEO_EFFECT_UPDATE",
+  AUDIO_FILTER_UPDATE: "AUDIO_FILTER_UPDATE",
+  TOGGLE_RANDOM: "TOGGLE_RANDOM",
+  API_VERSION_UPDATE: "API_VERSION_UPDATE",
+  PLAYLIST_UPDATE: "PLAYLIST_UPDATE",
+  TITLE_OR_CHAPTER_UPDATE: "TITLE_OR_CHAPTER_UPDATE",
+  NO_CHANGE: "NO_CHANGE"
+};
+
+// src/types/watchTogether.ts
+var SyncActions = {
+  PLAY: "play",
+  PAUSE: "pause",
+  SEEK: "seek"
+};
+var WatchTogetherErrorCodes = {
+  ROOM_NOT_FOUND: "ROOM_NOT_FOUND",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  ROOM_FULL: "ROOM_FULL",
+  INVALID_PASSWORD: "INVALID_PASSWORD",
+  NOT_IN_ROOM: "NOT_IN_ROOM",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  CONNECTION_ERROR: "CONNECTION_ERROR",
+  ALREADY_IN_ROOM: "ALREADY_IN_ROOM"
+};
+var WatchTogetherConstants = {
+  NAMESPACE: "/watch-together",
+  SYNC_CHECK_INTERVAL_MS: 3e4,
+  // 30 seconds
+  SYNC_TOLERANCE_SECONDS: 1,
+  // Time difference tolerance
+  MAX_RECONNECT_ATTEMPTS: 5,
+  RECONNECT_DELAY_MS: 2e3
+};
+var WatchTogetherIDs = {
+  JOIN_ROOM_INPUT: "join-room-code",
+  JOIN_AND_INVITE_SECTION: "join-invite-section",
+  JOIN_BUTTON: "join-room-button",
+  START_BUTTON: "watchtogether-start-button",
+  LEAVE_BUTTON: "watchtogether-leave-button",
+  JOINED_ROOM_SECTION: "joined-room-section",
+  ACTION_SECTION: "watchtogether-action-section",
+  CREATE_ROOM_BUTTON: "watchtogether-create-room-button"
+};
+var SECTION_NAMES = {
+  JOIN_AND_INVITE: "JOIN_AND_INVITE",
+  JOINED_ROOM: "JOINED_ROOM"
+};
+var WatchTogetherMessages = {
+  START_SUCCESS: "WatchTogether session started successfully!",
+  JOIN_SUCCESS: "Joined the WatchTogether session!",
+  LEAVE_SUCCESS: "You have left the WatchTogether session.",
+  INVALID_ARGS: "Missing required arguments. Please check the usage.",
+  CONNECTION_SUCCESS: "Connected to WatchTogether service.",
+  DISCONNECTED: "Disconnected from WatchTogether service."
+};
+
+// src/modules/watchTogether/WatchTogetherModule.ts
+var WatchTogetherModule = class {
+  // Flag for persistent connection
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.socket = null;
+    this.currentRoom = null;
+    this.syncInterval = null;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.connectionStatus = {
+      connected: false,
+      connecting: false,
+      authenticated: false,
+      inRoom: false,
+      roomId: null,
+      error: null
+    };
+    this.shouldStayConnected = false;
+    if (config.autoConnect || config.persistentConnection) {
+      this.initializePersistentConnection();
+    }
+  }
+  /**
+   * Initialize persistent connection (always on)
+   */
+  initializePersistentConnection() {
+    this.shouldStayConnected = true;
+    this.connect().catch(() => {
+      setTimeout(() => {
+        if (this.shouldStayConnected) {
+          this.initializePersistentConnection();
+        }
+      }, 2e3);
+    });
+  }
+  /**
+   * Connect to the Watch Together service
+   */
+  async connect() {
+    if (this.socket?.connected) {
+      this.updateConnectionStatus({ connected: true, connecting: false });
+      return;
+    }
+    const isPersistent = this.config.persistentConnection || this.shouldStayConnected;
+    const token = this.http.getAuthToken();
+    if (!token && !isPersistent) {
+      throw new WatchTogetherError("Authentication required. Please login first.", "UNAUTHORIZED");
+    }
+    this.updateConnectionStatus({ connecting: true, error: null });
+    const namespace = this.config.namespace || WatchTogetherConstants.NAMESPACE;
+    const url = `${this.config.baseURL}${namespace}`;
+    const socketOptions = {
+      query: { connectionId: "watchTogether" },
+      forceNew: !this.socket,
+      // Reuse socket if exists
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      // Infinite reconnection attempts
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      timeout: 1e4
+    };
+    if (token) {
+      socketOptions.extraHeaders = {
+        Authorization: `Bearer ${token}`
+      };
+      this.updateConnectionStatus({ authenticated: true });
+    }
+    this.socket = socket_ioClient.io(url, socketOptions);
+    this.setupSocketListeners();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (!isPersistent) {
+          reject(new WatchTogetherError("Connection timeout", "CONNECTION_ERROR"));
+        } else {
+          resolve();
+        }
+      }, 1e4);
+      this.socket.once("connect", () => {
+        clearTimeout(timeout);
+        this.updateConnectionStatus({
+          connected: true,
+          connecting: false,
+          error: null
+        });
+        this.emit("connect", void 0);
+        resolve();
+      });
+      this.socket.once("connect_error", (error) => {
+        clearTimeout(timeout);
+        this.updateConnectionStatus({
+          connected: false,
+          connecting: false,
+          error: error.message
+        });
+        if (!isPersistent) {
+          reject(new WatchTogetherError(error.message || "Connection failed", "CONNECTION_ERROR"));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Disconnect from the Watch Together service
+   */
+  disconnect() {
+    this.shouldStayConnected = false;
+    this.stopSyncCheck();
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.currentRoom = null;
+    this.updateConnectionStatus({
+      connected: false,
+      connecting: false,
+      authenticated: false,
+      inRoom: false,
+      roomId: null
+    });
+    this.emit("disconnect", "manual");
+  }
+  /**
+   * Enable persistent connection mode (always on)
+   */
+  enablePersistentConnection() {
+    if (!this.shouldStayConnected) {
+      this.shouldStayConnected = true;
+      this.initializePersistentConnection();
+    }
+  }
+  /**
+   * Disable persistent connection mode
+   */
+  disablePersistentConnection() {
+    this.shouldStayConnected = false;
+  }
+  /**
+   * Create a new room
+   */
+  async createRoom(options) {
+    this.ensureConnected();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new WatchTogetherError("Create room timeout", "CONNECTION_ERROR"));
+      }, 5e3);
+      this.socket.once("roomState", (room) => {
+        clearTimeout(timeout);
+        this.currentRoom = room;
+        this.startSyncCheck();
+        resolve(room);
+      });
+      this.socket.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(new WatchTogetherError(error.message, error.code));
+      });
+      this.socket.emit("createRoom", options || {});
+    });
+  }
+  /**
+   * Join an existing room or create a new one
+   */
+  async joinRoom(options) {
+    this.ensureConnected();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new WatchTogetherError("Join room timeout", "CONNECTION_ERROR"));
+      }, 5e3);
+      this.socket.once("roomState", (room) => {
+        clearTimeout(timeout);
+        this.currentRoom = room;
+        this.updateConnectionStatus({
+          inRoom: true,
+          roomId: room.roomId
+        });
+        this.startSyncCheck();
+        resolve(room);
+      });
+      this.socket.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(new WatchTogetherError(error.message, error.code));
+      });
+      this.socket.emit("joinRoom", options);
+    });
+  }
+  /**
+   * Leave the current room
+   */
+  leaveRoom() {
+    if (!this.currentRoom) {
+      return;
+    }
+    this.ensureConnected();
+    this.stopSyncCheck();
+    this.socket.emit("leaveRoom", { roomId: this.currentRoom.roomId });
+    this.currentRoom = null;
+    this.updateConnectionStatus({
+      inRoom: false,
+      roomId: null
+    });
+  }
+  /**
+   * Play the video (synced to all users)
+   */
+  play() {
+    this.ensureInRoom();
+    this.updateSyncState("play");
+  }
+  /**
+   * Pause the video (synced to all users)
+   */
+  pause() {
+    this.ensureInRoom();
+    this.updateSyncState("pause");
+  }
+  /**
+   * Seek to a specific time (synced to all users)
+   */
+  seek(timeInSeconds) {
+    this.ensureInRoom();
+    this.updateSyncState("seek", timeInSeconds);
+  }
+  /**
+   * Request sync state from server
+   */
+  requestSync() {
+    this.ensureInRoom();
+    this.socket.emit("checkSync", { roomId: this.currentRoom.roomId });
+  }
+  /**
+   * Update current file information
+   */
+  updateFileInfo(fileInfo) {
+    this.ensureInRoom();
+    this.socket.emit("updateFileInfo", {
+      roomId: this.currentRoom.roomId,
+      fileInfo
+    });
+  }
+  /**
+   * Send a chat message
+   */
+  async sendMessage(text) {
+    this.ensureInRoom();
+    const tempMessageId = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new WatchTogetherError("Send message timeout", "CONNECTION_ERROR"));
+      }, 5e3);
+      this.socket.once("chat:ack", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      this.socket.once("chat:error", (error) => {
+        clearTimeout(timeout);
+        reject(new WatchTogetherError(error.message, "CHAT_ERROR"));
+      });
+      this.socket.emit("chat:send", {
+        roomId: this.currentRoom.roomId,
+        text,
+        tempMessageId
+      });
+    });
+  }
+  /**
+   * Get chat history for current room
+   */
+  getChatHistory() {
+    return this.currentRoom?.chat || [];
+  }
+  /**
+   * Get current room state
+   */
+  getCurrentRoom() {
+    return this.currentRoom;
+  }
+  /**
+   * Check if connected to the service
+   */
+  isConnected() {
+    return this.socket?.connected || false;
+  }
+  /**
+   * Check if currently in a room
+   */
+  isInRoom() {
+    return this.currentRoom !== null;
+  }
+  /**
+   * Get current connection status
+   */
+  getConnectionStatus() {
+    return { ...this.connectionStatus };
+  }
+  /**
+   * Check if user is online (connected to socket)
+   */
+  isOnline() {
+    return this.connectionStatus.connected;
+  }
+  // ============================================
+  // EVENT LISTENERS
+  // ============================================
+  /**
+   * Listen for room state events
+   */
+  onRoomState(callback) {
+    return this.addEventListener("roomState", callback);
+  }
+  /**
+   * Listen for room update events
+   */
+  onRoomUpdate(callback) {
+    return this.addEventListener("roomUpdates", callback);
+  }
+  /**
+   * Listen for sync state events
+   */
+  onSyncState(callback) {
+    return this.addEventListener("syncState", callback);
+  }
+  /**
+   * Listen for chat messages
+   */
+  onChatMessage(callback) {
+    return this.addEventListener("chat:receive", callback);
+  }
+  /**
+   * Listen for system messages
+   */
+  onSystemMessage(callback) {
+    return this.addEventListener("newMessage", callback);
+  }
+  /**
+   * Listen for chat history
+   */
+  onChatHistory(callback) {
+    return this.addEventListener("chatHistory", callback);
+  }
+  /**
+   * Listen for errors
+   */
+  onError(callback) {
+    return this.addEventListener("error", callback);
+  }
+  /**
+   * Listen for connection events
+   */
+  onConnect(callback) {
+    return this.addEventListener("connect", callback);
+  }
+  /**
+   * Listen for disconnection events
+   */
+  onDisconnect(callback) {
+    return this.addEventListener("disconnect", callback);
+  }
+  /**
+   * Listen for connection status changes
+   */
+  onConnectionStatusChange(callback) {
+    return this.addEventListener("connectionStatusChange", callback);
+  }
+  /**
+   * Listen for online/offline status
+   */
+  onOnlineStatusChange(callback) {
+    return this.addEventListener("onlineStatusChange", callback);
+  }
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+  setupSocketListeners() {
+    if (!this.socket) return;
+    this.socket.on("roomState", (room) => {
+      this.currentRoom = room;
+      this.updateConnectionStatus({
+        inRoom: true,
+        roomId: room.roomId
+      });
+      this.emit("roomState", room);
+    });
+    this.socket.on("roomUpdates", (update) => {
+      if (this.currentRoom && update.roomUpdates) {
+        this.currentRoom = {
+          ...this.currentRoom,
+          ...update.roomUpdates
+        };
+      }
+      this.emit("roomUpdates", update);
+    });
+    this.socket.on("syncState", (syncState) => {
+      if (this.currentRoom) {
+        this.currentRoom.syncState = syncState;
+      }
+      this.emit("syncState", syncState);
+    });
+    this.socket.on("chat:receive", (data) => {
+      if (this.currentRoom) {
+        this.currentRoom.chat.push(data.message);
+      }
+      this.emit("chat:receive", data.message);
+    });
+    this.socket.on("newMessage", (data) => {
+      const message = { ...data.message, systemMessage: true };
+      if (this.currentRoom) {
+        this.currentRoom.chat.push(message);
+      }
+      this.emit("newMessage", message);
+    });
+    this.socket.on("chatHistory", (data) => {
+      if (this.currentRoom) {
+        this.currentRoom.chat = data.messages;
+      }
+      this.emit("chatHistory", data.messages);
+    });
+    this.socket.on("chat:ack", (data) => {
+      this.emit("chat:ack", data.message);
+    });
+    this.socket.on("chat:error", (data) => {
+      this.emit("chat:error", data);
+    });
+    this.socket.on("error", (data) => {
+      this.updateConnectionStatus({ error: data.message });
+      this.emit("error", data);
+    });
+    this.socket.on("connect", () => {
+      this.updateConnectionStatus({
+        connected: true,
+        connecting: false,
+        error: null
+      });
+    });
+    this.socket.on("disconnect", (reason) => {
+      this.stopSyncCheck();
+      this.updateConnectionStatus({
+        connected: false,
+        error: `Disconnected: ${reason}`
+      });
+      this.emit("disconnect", reason);
+      if (this.shouldStayConnected) {
+        setTimeout(() => {
+          if (this.shouldStayConnected && !this.socket?.connected) {
+            this.connect().catch(() => {
+            });
+          }
+        }, 2e3);
+      }
+    });
+    this.socket.on("connect_error", async (error) => {
+      this.updateConnectionStatus({
+        connected: false,
+        connecting: false,
+        error: error.message
+      });
+      if (error.message.includes("Unauthorized") || error.message.includes("401")) {
+        try {
+          await this.refreshTokenAndReconnect();
+        } catch {
+          this.emit("error", {
+            code: "UNAUTHORIZED",
+            message: "Session expired. Please login again."
+          });
+        }
+      }
+      if (this.shouldStayConnected) {
+        setTimeout(() => {
+          if (this.shouldStayConnected && !this.socket?.connected) {
+            this.connect().catch(() => {
+            });
+          }
+        }, 3e3);
+      }
+    });
+    this.socket.on("reconnect_attempt", (attempt) => {
+      this.updateConnectionStatus({
+        connecting: true,
+        error: `Reconnecting (attempt ${attempt})...`
+      });
+    });
+    this.socket.on("reconnect", (_attempt) => {
+      this.updateConnectionStatus({
+        connected: true,
+        connecting: false,
+        error: null
+      });
+      this.emit("connect", void 0);
+    });
+    this.socket.on("reconnect_failed", () => {
+      this.updateConnectionStatus({
+        connected: false,
+        connecting: false,
+        error: "Reconnection failed"
+      });
+      if (this.shouldStayConnected) {
+        setTimeout(() => {
+          if (this.shouldStayConnected) {
+            this.connect().catch(() => {
+            });
+          }
+        }, 5e3);
+      }
+    });
+  }
+  async refreshTokenAndReconnect() {
+    if (!this.shouldStayConnected) {
+      this.disconnect();
+      throw new WatchTogetherError("Session expired. Please login again.", "UNAUTHORIZED");
+    }
+    this.updateConnectionStatus({ authenticated: false });
+  }
+  /**
+   * Update authentication token after refresh
+   */
+  updateAuthToken(token) {
+    if (this.socket && this.socket.io.opts.extraHeaders) {
+      this.socket.io.opts.extraHeaders.Authorization = `Bearer ${token}`;
+      this.updateConnectionStatus({ authenticated: true, error: null });
+      if (!this.socket.connected) {
+        this.socket.connect();
+      }
+    }
+  }
+  /**
+   * Update connection status and emit events
+   */
+  updateConnectionStatus(updates) {
+    const previousOnlineStatus = this.connectionStatus.connected;
+    this.connectionStatus = {
+      ...this.connectionStatus,
+      ...updates
+    };
+    this.emit("connectionStatusChange", this.connectionStatus);
+    if (previousOnlineStatus !== this.connectionStatus.connected) {
+      this.emit("onlineStatusChange", this.connectionStatus.connected);
+    }
+  }
+  updateSyncState(action, value) {
+    this.ensureInRoom();
+    const payload = {
+      roomId: this.currentRoom.roomId,
+      action
+    };
+    if (action === "seek" && value !== void 0) {
+      payload.value = value;
+    }
+    this.socket.emit("updateSyncState", payload);
+  }
+  startSyncCheck() {
+    this.stopSyncCheck();
+    this.syncInterval = setInterval(() => {
+      if (this.currentRoom && this.socket?.connected) {
+        this.socket.emit("checkSync", { roomId: this.currentRoom.roomId });
+      }
+    }, WatchTogetherConstants.SYNC_CHECK_INTERVAL_MS);
+  }
+  stopSyncCheck() {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+    }
+  }
+  ensureConnected() {
+    if (!this.socket?.connected) {
+      throw new WatchTogetherError(
+        "Not connected. Please call connect() first.",
+        "CONNECTION_ERROR"
+      );
+    }
+  }
+  ensureInRoom() {
+    this.ensureConnected();
+    if (!this.currentRoom) {
+      throw new WatchTogetherError(
+        "Not in a room. Please join or create a room first.",
+        "NOT_IN_ROOM"
+      );
+    }
+  }
+  addEventListener(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+    return () => {
+      const listeners = this.eventListeners.get(event);
+      if (listeners) {
+        listeners.delete(callback);
+      }
+    };
+  }
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in event listener for ${event}:`, error);
+        }
+      });
+    }
+  }
+};
+
+// src/sdk/HarmoniSDK.ts
+var HarmoniSDK = class {
+  constructor(config) {
+    this.httpClient = new HttpClient(config);
+    if (config.autoRefreshToken) {
+      this.setupAutoRefresh();
+    }
+    this.auth = new AuthModule(this.httpClient);
+    this.user = new UserModule(this.httpClient);
+    this.watchTogether = new WatchTogetherModule(this.httpClient, {
+      baseURL: config.baseURL,
+      namespace: config.watchTogetherNamespace,
+      persistentConnection: config.persistentConnection
+    });
+  }
+  /**
+   * Setup automatic token refresh
+   */
+  setupAutoRefresh() {
+    this.httpClient.setRefreshTokenFunction(async () => {
+      const accessToken = await this.auth.refreshAccessToken();
+      this.storeAccessToken(accessToken);
+      return accessToken;
+    });
+  }
+  /**
+   * Set authentication token
+   */
+  setAuthToken(token) {
+    this.httpClient.setAuthToken(token);
+  }
+  /**
+   * Get current authentication token
+   */
+  getAuthToken() {
+    return this.httpClient.getAuthToken();
+  }
+  /**
+   * Store access token (override this method or use storage)
+   */
+  storeAccessToken(accessToken) {
+    if (typeof globalThis !== "undefined" && "localStorage" in globalThis) {
+      const storage = globalThis.localStorage;
+      storage?.setItem("harmoni_access_token", accessToken);
+    }
+  }
+  /**
+   * Get the underlying HTTP client (for advanced usage)
+   */
+  getHttpClient() {
+    return this.httpClient;
+  }
+};
+
+// src/types/player.ts
+var PlayerConstants = {
+  DEFAULT_POLLING_INTERVAL_MS: 2e3,
+  SEEK_THRESHOLD_SECONDS: 0.5,
+  COMMAND_STACK_TIMEOUT_MS: 3e3,
+  MIN_INTERVAL_MS: 100
+};
+
+// src/utils/string.ts
+var string_exports = {};
+__export(string_exports, {
+  camelToSnake: () => camelToSnake,
+  capitalize: () => capitalize,
+  isValidEmail: () => isValidEmail,
+  randomString: () => randomString,
+  slugify: () => slugify,
+  snakeToCamel: () => snakeToCamel,
+  titleCase: () => titleCase,
+  truncate: () => truncate
+});
+function capitalize(str) {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function titleCase(str) {
+  if (!str) return "";
+  return str.toLowerCase().split(" ").map((word) => capitalize(word)).join(" ");
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function truncate(str, length, suffix = "...") {
+  if (!str || str.length <= length) return str;
+  return str.slice(0, length - suffix.length) + suffix;
+}
+function isValidEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function randomString(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+function slugify(str) {
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/utils/date.ts
+var date_exports = {};
+__export(date_exports, {
+  addDays: () => addDays,
+  addHours: () => addHours,
+  formatDate: () => formatDate,
+  isFuture: () => isFuture,
+  isPast: () => isPast,
+  isToday: () => isToday,
+  isValidDate: () => isValidDate,
+  timeAgo: () => timeAgo,
+  toISOString: () => toISOString
+});
+function toISOString(date) {
+  return new Date(date).toISOString();
+}
+function isValidDate(date) {
+  return date instanceof Date && !isNaN(date.getTime());
+}
+function timeAgo(date) {
+  const now = /* @__PURE__ */ new Date();
+  const past = new Date(date);
+  const diffInSeconds = Math.floor((now.getTime() - past.getTime()) / 1e3);
+  if (diffInSeconds < 60) return "just now";
+  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)} minutes ago`;
+  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)} hours ago`;
+  if (diffInSeconds < 604800) return `${Math.floor(diffInSeconds / 86400)} days ago`;
+  if (diffInSeconds < 2592e3) return `${Math.floor(diffInSeconds / 604800)} weeks ago`;
+  if (diffInSeconds < 31536e3) return `${Math.floor(diffInSeconds / 2592e3)} months ago`;
+  return `${Math.floor(diffInSeconds / 31536e3)} years ago`;
+}
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addHours(date, hours) {
+  const result = new Date(date);
+  result.setHours(result.getHours() + hours);
+  return result;
+}
+function formatDate(date, format = "YYYY-MM-DD") {
+  const d = new Date(date);
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+}
+function isToday(date) {
+  const today = /* @__PURE__ */ new Date();
+  const checkDate = new Date(date);
+  return checkDate.getDate() === today.getDate() && checkDate.getMonth() === today.getMonth() && checkDate.getFullYear() === today.getFullYear();
+}
+function isPast(date) {
+  return new Date(date).getTime() < Date.now();
+}
+function isFuture(date) {
+  return new Date(date).getTime() > Date.now();
+}
+
+// src/utils/object.ts
+var object_exports = {};
+__export(object_exports, {
+  deepClone: () => deepClone,
+  deepMerge: () => deepMerge,
+  getNestedValue: () => getNestedValue,
+  isEmpty: () => isEmpty,
+  isObject: () => isObject,
+  omit: () => omit,
+  pick: () => pick,
+  setNestedValue: () => setNestedValue
+});
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj instanceof Date) return new Date(obj.getTime());
+  if (obj instanceof Array) return obj.map((item) => deepClone(item));
+  if (obj instanceof Object) {
+    const clonedObj = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        clonedObj[key] = deepClone(obj[key]);
+      }
+    }
+    return clonedObj;
+  }
+  return obj;
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (isObject(sourceValue) && isObject(targetValue)) {
+        output[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        output[key] = sourceValue;
+      }
+    });
+  }
+  return output;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pick(obj, keys) {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  keys.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function isEmpty(obj) {
+  if (obj === null || obj === void 0) return true;
+  if (typeof obj === "string" || Array.isArray(obj)) return obj.length === 0;
+  if (typeof obj === "object") return Object.keys(obj).length === 0;
+  return false;
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result && typeof result === "object" && key in result) {
+      result = result[key];
+    } else {
+      return void 0;
+    }
+  }
+  return result;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+  let current = obj;
+  for (const key of keys) {
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[lastKey] = value;
+}
+
+// src/utils/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  maxLength: () => maxLength,
+  minLength: () => minLength,
+  required: () => required,
+  validateEmail: () => validateEmail,
+  validatePassword: () => validatePassword,
+  validatePhone: () => validatePhone,
+  validateUrl: () => validateUrl
+});
+function validateEmail(email) {
+  if (!email) {
+    return { valid: false, message: "Email is required" };
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return { valid: false, message: "Invalid email format" };
+  }
+  return { valid: true };
+}
+function validatePassword(password, options = {}) {
+  const {
+    minLength: minLength2 = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumbers = true,
+    requireSpecialChars = true
+  } = options;
+  if (!password) {
+    return { valid: false, message: "Password is required" };
+  }
+  if (password.length < minLength2) {
+    return { valid: false, message: `Password must be at least ${minLength2} characters` };
+  }
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    return { valid: false, message: "Password must contain at least one uppercase letter" };
+  }
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    return { valid: false, message: "Password must contain at least one lowercase letter" };
+  }
+  if (requireNumbers && !/\d/.test(password)) {
+    return { valid: false, message: "Password must contain at least one number" };
+  }
+  if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+    return { valid: false, message: "Password must contain at least one special character" };
+  }
+  return { valid: true };
+}
+function validateUrl(url) {
+  if (!url) {
+    return { valid: false, message: "URL is required" };
+  }
+  try {
+    new URL(url);
+    return { valid: true };
+  } catch {
+    return { valid: false, message: "Invalid URL format" };
+  }
+}
+function validatePhone(phone) {
+  if (!phone) {
+    return { valid: false, message: "Phone number is required" };
+  }
+  const phoneRegex = /^[+]?[(]?[0-9]{1,4}[)]?[-\s.]?[(]?[0-9]{1,4}[)]?[-\s.]?[0-9]{1,9}$/;
+  if (!phoneRegex.test(phone)) {
+    return { valid: false, message: "Invalid phone number format" };
+  }
+  return { valid: true };
+}
+function required(value, fieldName = "Field") {
+  if (value === null || value === void 0 || value === "") {
+    return { valid: false, message: `${fieldName} is required` };
+  }
+  return { valid: true };
+}
+function minLength(value, min, fieldName = "Field") {
+  if (value.length < min) {
+    return { valid: false, message: `${fieldName} must be at least ${min} characters` };
+  }
+  return { valid: true };
+}
+function maxLength(value, max, fieldName = "Field") {
+  if (value.length > max) {
+    return { valid: false, message: `${fieldName} must be at most ${max} characters` };
+  }
+  return { valid: true };
+}
+
+// src/utils/storage.ts
+var isBrowser = typeof globalThis !== "undefined" && "localStorage" in globalThis;
+var Storage = class {
+  constructor(type = "local") {
+    this.memoryStorage = /* @__PURE__ */ new Map();
+    if (isBrowser) {
+      const global = globalThis;
+      this.storage = type === "local" ? global.localStorage ?? null : global.sessionStorage ?? null;
+    } else {
+      this.storage = null;
+    }
+  }
+  /**
+   * Set item in storage
+   */
+  set(key, value) {
+    try {
+      const serialized = JSON.stringify(value);
+      if (this.storage) {
+        this.storage.setItem(key, serialized);
+      } else {
+        this.memoryStorage.set(key, serialized);
+      }
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error(`Error saving to storage:`, error);
+      }
+    }
+  }
+  /**
+   * Get item from storage
+   */
+  get(key) {
+    try {
+      let item;
+      if (this.storage) {
+        item = this.storage.getItem(key);
+      } else {
+        item = this.memoryStorage.get(key);
+      }
+      if (!item) return null;
+      return JSON.parse(item);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error(`Error reading from storage:`, error);
+      }
+      return null;
+    }
+  }
+  /**
+   * Remove item from storage
+   */
+  remove(key) {
+    try {
+      if (this.storage) {
+        this.storage.removeItem(key);
+      } else {
+        this.memoryStorage.delete(key);
+      }
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error(`Error removing from storage:`, error);
+      }
+    }
+  }
+  /**
+   * Clear all items from storage
+   */
+  clear() {
+    try {
+      if (this.storage) {
+        this.storage.clear();
+      } else {
+        this.memoryStorage.clear();
+      }
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error(`Error clearing storage:`, error);
+      }
+    }
+  }
+  /**
+   * Check if key exists in storage
+   */
+  has(key) {
+    if (this.storage) {
+      return this.storage.getItem(key) !== null;
+    } else {
+      return this.memoryStorage.has(key);
+    }
+  }
+  /**
+   * Get all keys from storage
+   */
+  keys() {
+    if (this.storage) {
+      return Object.keys(this.storage);
+    } else {
+      return Array.from(this.memoryStorage.keys());
+    }
+  }
+  /**
+   * Check if storage is available (browser environment)
+   */
+  isAvailable() {
+    return this.storage !== null;
+  }
+};
+var localStorage = new Storage("local");
+var sessionStorage = new Storage("session");
+
+// src/player/stateDetection.ts
+function identifyUserActions(oldState, newState, intervalMs) {
+  const actions = [];
+  if (!oldState || !newState) return [];
+  const normalizedInterval = Math.max(intervalMs, PlayerConstants.MIN_INTERVAL_MS);
+  if (oldState.isPlaying !== newState.isPlaying) {
+    actions.push({
+      event: newState.isPlaying ? USER_ACTIONS.PLAY : USER_ACTIONS.PAUSE,
+      value: {
+        isPlaying: newState.isPlaying,
+        currentTime: newState.currentTime
+      }
+    });
+  }
+  const timeDifference = Math.abs(oldState.currentTime - newState.currentTime);
+  const expectedTimeAdvance = normalizedInterval / 1e3 * (newState.isPlaying ? 1 : 0);
+  const seekThreshold = Math.max(PlayerConstants.SEEK_THRESHOLD_SECONDS, expectedTimeAdvance * 1.5);
+  if (timeDifference > expectedTimeAdvance + seekThreshold) {
+    actions.push({
+      event: USER_ACTIONS.SEEK,
+      value: { currentTime: newState.currentTime }
+    });
+  }
+  if (oldState.filename !== newState.filename) {
+    actions.push({
+      event: USER_ACTIONS.FILE_UPDATE,
+      value: {
+        filename: newState.filename === "no-input" ? null : newState.filename
+      }
+    });
+  }
+  if (oldState.loop !== newState.loop) {
+    actions.push({
+      event: USER_ACTIONS.TOGGLE_LOOP,
+      value: { loop: newState.loop }
+    });
+  }
+  if (oldState.repeat !== newState.repeat) {
+    actions.push({
+      event: USER_ACTIONS.TOGGLE_REPEAT,
+      value: { repeat: newState.repeat }
+    });
+  }
+  if (oldState.title !== newState.title || oldState.chapter !== newState.chapter) {
+    actions.push({
+      event: USER_ACTIONS.TITLE_OR_CHAPTER_UPDATE,
+      value: { title: newState.title, chapter: newState.chapter }
+    });
+  }
+  return actions;
+}
+function normalizePlayerState(state) {
+  return {
+    isPlaying: state.isPlaying ?? false,
+    currentTime: Number.isFinite(state.currentTime) ? state.currentTime : 0,
+    loop: state.loop ?? false,
+    repeat: state.repeat ?? false,
+    title: state.title ?? "",
+    chapter: state.chapter ?? "",
+    filename: state.filename ?? "",
+    duration: Number.isFinite(state.duration) ? state.duration : 0,
+    filepath: state.filepath ?? ""
+  };
+}
+
+// src/player/PlayerStatusMonitor.ts
+var PlayerStatusMonitor = class {
+  constructor(player, onStateChange, onStop, pollingIntervalMs = PlayerConstants.DEFAULT_POLLING_INTERVAL_MS) {
+    this.player = player;
+    this.onStateChange = onStateChange;
+    this.onStop = onStop;
+    this.pollingIntervalMs = pollingIntervalMs;
+    this.lastKnownState = null;
+    this.lastCheckTime = 0;
+    this.pollingTimer = null;
+    this.isRunning = false;
+  }
+  /**
+   * Starts monitoring the player status.
+   */
+  start() {
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.lastCheckTime = Date.now();
+    this.checkStatus();
+  }
+  /**
+   * Stops monitoring the player status.
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.pollingTimer) {
+      clearTimeout(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+  }
+  /**
+   * Check if monitor is currently running.
+   */
+  getIsRunning() {
+    return this.isRunning;
+  }
+  /**
+   * Get the last known player state.
+   */
+  getLastKnownState() {
+    return this.lastKnownState;
+  }
+  /**
+   * Manually update the last known state (used when app initiates actions).
+   */
+  updateLastKnownState(state) {
+    this.lastKnownState = state;
+  }
+  async checkStatus() {
+    if (!this.isRunning) {
+      return;
+    }
+    try {
+      const isRunning = await this.player.checkPlayerRunning();
+      if (!isRunning) {
+        this.isRunning = false;
+        this.onStop();
+        return;
+      }
+      const currentTime = Date.now();
+      const timeSinceLastCheck = this.lastCheckTime > 0 ? currentTime - this.lastCheckTime : this.pollingIntervalMs;
+      this.lastCheckTime = currentTime;
+      const currentState = await this.player.getStatus();
+      if (this.lastKnownState) {
+        const detectedActions = identifyUserActions(
+          this.lastKnownState,
+          currentState,
+          timeSinceLastCheck
+        );
+        if (detectedActions.length > 0) {
+          const source = this.determineActionSource(detectedActions);
+          this.onStateChange(detectedActions, source);
+        }
+      }
+      this.lastKnownState = currentState;
+      if (this.isRunning) {
+        this.pollingTimer = setTimeout(() => this.checkStatus(), this.pollingIntervalMs);
+      }
+    } catch (error) {
+      console.error("Error fetching player status:", error);
+      this.isRunning = false;
+      this.onStop();
+    }
+  }
+  /**
+   * Determines if the action came from app sync or user interaction.
+   * Should be overridden to integrate with command tracking.
+   */
+  determineActionSource(_actions) {
+    return "user";
+  }
+};
+
+// src/player/HTML5VideoController.ts
+var HTML5VideoController = class {
+  constructor(videoElementId) {
+    this.videoElementId = videoElementId;
+    this.video = null;
+    this.statusMonitor = null;
+  }
+  async start(onReady) {
+    if (typeof document === "undefined") {
+      throw new Error("HTML5VideoController requires a browser environment");
+    }
+    this.video = document.getElementById(this.videoElementId);
+    if (!this.video) {
+      throw new Error(`Video element with id "${this.videoElementId}" not found`);
+    }
+    if (this.video.readyState >= 2) {
+      onReady?.();
+    } else {
+      this.video.addEventListener("canplay", () => onReady?.(), { once: true });
+    }
+  }
+  async play() {
+    if (!this.video) {
+      throw new Error("Player not initialized");
+    }
+    await this.video.play();
+  }
+  async pause() {
+    if (!this.video) {
+      throw new Error("Player not initialized");
+    }
+    this.video.pause();
+  }
+  async stop() {
+    if (this.video) {
+      this.video.pause();
+      this.video.currentTime = 0;
+    }
+  }
+  async seek(timeInSeconds) {
+    if (!this.video) {
+      throw new Error("Player not initialized");
+    }
+    this.video.currentTime = timeInSeconds;
+  }
+  async loadMedia(source) {
+    if (!this.video) {
+      throw new Error("Player not initialized");
+    }
+    this.video.src = source;
+    this.video.load();
+  }
+  async getStatus() {
+    if (!this.video) {
+      throw new Error("Player not initialized");
+    }
+    return {
+      isPlaying: !this.video.paused && !this.video.ended,
+      currentTime: this.video.currentTime,
+      loop: this.video.loop,
+      repeat: false,
+      title: "",
+      chapter: "",
+      filename: this.video.src.split("/").pop() || "",
+      duration: Number.isFinite(this.video.duration) ? this.video.duration : 0,
+      filepath: this.video.src
+    };
+  }
+  async checkPlayerRunning() {
+    return this.video !== null && this.video.readyState >= 2;
+  }
+  async quit() {
+    if (this.video) {
+      this.video.pause();
+      this.video.src = "";
+    }
+    this.statusMonitor?.stop();
+  }
+  observeStatusChange(onChange, onStop, intervalMs = 500) {
+    this.statusMonitor?.stop();
+    this.statusMonitor = new PlayerStatusMonitor(this, onChange, onStop, intervalMs);
+    this.statusMonitor.start();
+  }
+  async displayMessage(message, durationSeconds = 5) {
+    console.log(`[Player OSD] ${message} (${durationSeconds}s)`);
+  }
+  /**
+   * Get the underlying HTMLVideoElement (for advanced usage).
+   */
+  getVideoElement() {
+    return this.video;
+  }
+};
+
+// src/player/SyncedPlayer.ts
+var SyncedPlayer = class {
+  constructor(player, watchTogether, options) {
+    this.player = player;
+    this.watchTogether = watchTogether;
+    this.options = options;
+    this.commandStack = [];
+    this.currentUserId = null;
+    this.unsubscribers = [];
+    this.currentUserId = options.getCurrentUserId();
+    this.setupListeners();
+  }
+  /**
+   * Setup listeners for sync and player changes.
+   */
+  setupListeners() {
+    const unsubRoomUpdate = this.watchTogether.onRoomUpdate((update) => {
+      this.handleRemoteSyncUpdate(update);
+    });
+    this.unsubscribers.push(unsubRoomUpdate);
+    this.player.observeStatusChange(
+      (actions, _source) => this.handleLocalPlayerChange(actions),
+      () => {
+        this.options.onPlayerStopped?.();
+      }
+    );
+  }
+  /**
+   * Handle sync updates from other users.
+   */
+  async handleRemoteSyncUpdate(update) {
+    const { action, userId } = update.metadata;
+    if (userId === this.currentUserId) {
+      return;
+    }
+    this.commandStack.push({ action, timestamp: Date.now() });
+    try {
+      switch (action) {
+        case "play":
+          await this.player.play();
+          break;
+        case "pause":
+          await this.player.pause();
+          break;
+        case "seek": {
+          const time = update.roomUpdates.syncState?.time;
+          if (time !== void 0) {
+            await this.player.seek(time);
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      console.error("Error applying remote sync update:", error);
+    }
+  }
+  /**
+   * Handle local player changes and broadcast to room.
+   */
+  handleLocalPlayerChange(actions) {
+    for (const action of actions) {
+      const isFromSync = this.popMatchingCommand(action.event);
+      if (isFromSync) {
+        continue;
+      }
+      try {
+        switch (action.event) {
+          case USER_ACTIONS.PLAY:
+            this.watchTogether.play();
+            break;
+          case USER_ACTIONS.PAUSE:
+            this.watchTogether.pause();
+            break;
+          case USER_ACTIONS.SEEK: {
+            const time = action.value?.currentTime;
+            if (time !== void 0) {
+              this.watchTogether.seek(time);
+            }
+            break;
+          }
+          case USER_ACTIONS.FILE_UPDATE: {
+            const filename = action.value?.filename;
+            if (filename) {
+            }
+            break;
+          }
+        }
+      } catch (error) {
+        console.error("Error broadcasting player action:", error);
+      }
+    }
+  }
+  /**
+   * Check if a matching command exists in the stack (from sync).
+   * Returns true if found (and removes it from stack).
+   */
+  popMatchingCommand(event) {
+    const now = Date.now();
+    this.commandStack = this.commandStack.filter(
+      (cmd) => now - cmd.timestamp < PlayerConstants.COMMAND_STACK_TIMEOUT_MS
+    );
+    const index = this.commandStack.findIndex(
+      (cmd) => cmd.action === this.eventToAction(event) && now - cmd.timestamp < PlayerConstants.COMMAND_STACK_TIMEOUT_MS
+    );
+    if (index !== -1) {
+      this.commandStack.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Map user action event to sync action name.
+   */
+  eventToAction(event) {
+    const mapping = {
+      [USER_ACTIONS.PLAY]: "play",
+      [USER_ACTIONS.PAUSE]: "pause",
+      [USER_ACTIONS.SEEK]: "seek"
+    };
+    return mapping[event] || event.toLowerCase();
+  }
+  /**
+   * Cleanup listeners.
+   */
+  destroy() {
+    this.unsubscribers.forEach((unsub) => unsub());
+    this.unsubscribers = [];
+    this.commandStack = [];
+  }
+};
+
+exports.ApiError = ApiError;
+exports.AuthModule = AuthModule;
+exports.ForbiddenError = ForbiddenError;
+exports.HTML5VideoController = HTML5VideoController;
+exports.HarmoniSDK = HarmoniSDK;
+exports.HttpClient = HttpClient;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.PlayerConstants = PlayerConstants;
+exports.PlayerStatusMonitor = PlayerStatusMonitor;
+exports.SECTION_NAMES = SECTION_NAMES;
+exports.Storage = Storage;
+exports.SyncActions = SyncActions;
+exports.SyncedPlayer = SyncedPlayer;
+exports.TimeoutError = TimeoutError;
+exports.USER_ACTIONS = USER_ACTIONS;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UserModule = UserModule;
+exports.ValidationError = ValidationError;
+exports.WatchTogetherConstants = WatchTogetherConstants;
+exports.WatchTogetherError = WatchTogetherError;
+exports.WatchTogetherErrorCodes = WatchTogetherErrorCodes;
+exports.WatchTogetherIDs = WatchTogetherIDs;
+exports.WatchTogetherMessages = WatchTogetherMessages;
+exports.WatchTogetherModule = WatchTogetherModule;
+exports.dateUtils = date_exports;
+exports.default = HarmoniSDK;
+exports.identifyUserActions = identifyUserActions;
+exports.localStorage = localStorage;
+exports.normalizePlayerState = normalizePlayerState;
+exports.objectUtils = object_exports;
+exports.sessionStorage = sessionStorage;
+exports.stringUtils = string_exports;
+exports.validationUtils = validation_exports;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map