saltfish 0.2.50 → 0.2.52

package/dist/saltfish-playlist-player.es.js

@@ -951,280 +951,6 @@ const playerStateMachineConfig = {
     }
   }
 };
-const STORAGE_KEYS = {
-  PROGRESS: "saltfish_progress",
-  SESSION: "saltfish_session",
-  ANONYMOUS_USER: "saltfish_anonymous_user_data"
-};
-const TIMING = {
-  // 5 seconds
-  STEP_TIMEOUT: 6e4,
-  // Session persistence
-  SESSION_EXPIRY: 30 * 60 * 1e3
-  // 30 minutes in milliseconds
-};
-const API = {
-  BASE_URL: "https://player.saltfish.ai",
-  ENDPOINTS: {
-    VALIDATE_TOKEN: "/validate-token",
-    USERS: "/clients/{token}/users/{userId}"
-  }
-};
-const CSS_CLASSES = {
-  PLAYER: "sf-player",
-  PLAYER_MINIMIZED: "sf-player--minimized",
-  CONTROLS_CONTAINER: "sf-controls-container",
-  LOGO: "sf-player__logo",
-  // Legacy error class
-  ERROR_DISPLAY: "sf-error-display",
-  ERROR_DISPLAY_VISIBLE: "sf-error-display--visible",
-  ERROR_DISPLAY_CONTENT: "sf-error-display__content",
-  ERROR_DISPLAY_MESSAGE: "sf-error-display__message",
-  LOADING_SPINNER: "sf-loading-spinner"
-};
-class StorageManager {
-  constructor() {
-    __publicField(this, "isLocalStorageAvailable");
-    this.isLocalStorageAvailable = this.checkLocalStorageAvailability();
-    if (!this.isLocalStorageAvailable) ;
-  }
-  /**
-   * Check if localStorage is available and working
-   */
-  checkLocalStorageAvailability() {
-    if (typeof window === "undefined") {
-      return false;
-    }
-    try {
-      const testKey = "__storage_test__";
-      localStorage.setItem(testKey, "test");
-      localStorage.removeItem(testKey);
-      return true;
-    } catch (error2) {
-      return false;
-    }
-  }
-  /**
-   * Safely get an item from localStorage with JSON parsing
-   */
-  safeGetItem(key) {
-    if (!this.isLocalStorageAvailable) {
-      return null;
-    }
-    try {
-      const item = localStorage.getItem(key);
-      if (item === null) {
-        return null;
-      }
-      return JSON.parse(item);
-    } catch (error2) {
-      this.safeClearItem(key);
-      return null;
-    }
-  }
-  /**
-   * Safely set an item in localStorage with JSON stringification
-   */
-  safeSetItem(key, value) {
-    if (!this.isLocalStorageAvailable) {
-      return false;
-    }
-    try {
-      localStorage.setItem(key, JSON.stringify(value));
-      return true;
-    } catch (error2) {
-      if (error2 instanceof DOMException && error2.code === 22) {
-        this.clearOldData();
-        try {
-          localStorage.setItem(key, JSON.stringify(value));
-          return true;
-        } catch (retryError) {
-        }
-      }
-      return false;
-    }
-  }
-  /**
-   * Safely clear an item from localStorage
-   */
-  safeClearItem(key) {
-    if (!this.isLocalStorageAvailable) {
-      return;
-    }
-    try {
-      localStorage.removeItem(key);
-    } catch (error2) {
-    }
-  }
-  /**
-   * Clear old data to free up storage space
-   */
-  clearOldData() {
-    this.safeClearItem(STORAGE_KEYS.SESSION);
-  }
-  // =============================================================================
-  // Progress Data Methods
-  // =============================================================================
-  /**
-   * Get playlist progress data for a specific user
-   * If userId doesn't match stored userId, returns null (stale data)
-   * @param userId - The user ID to validate against stored data
-   */
-  getProgress(userId) {
-    const stored = this.safeGetItem(STORAGE_KEYS.PROGRESS);
-    if (!stored) {
-      return null;
-    }
-    if (userId && stored.userId && stored.userId !== userId) {
-      log(`[StorageManager] Progress belongs to different user (${stored.userId}), ignoring`);
-      return null;
-    }
-    return stored.playlists || null;
-  }
-  /**
-   * Set playlist progress data for a specific user
-   * Clears existing data if userId changes
-   * @param progress - The progress data to save
-   * @param userId - The user ID to associate with this progress
-   */
-  setProgress(progress, userId) {
-    const stored = {
-      userId,
-      playlists: progress
-    };
-    return this.safeSetItem(STORAGE_KEYS.PROGRESS, stored);
-  }
-  /**
-   * Clear all progress data
-   */
-  clearProgress() {
-    this.safeClearItem(STORAGE_KEYS.PROGRESS);
-  }
-  // =============================================================================
-  // Session Data Methods  
-  // =============================================================================
-  /**
-   * Get session data
-   */
-  getSession() {
-    return this.safeGetItem(STORAGE_KEYS.SESSION);
-  }
-  /**
-   * Set session data
-   */
-  setSession(session) {
-    return this.safeSetItem(STORAGE_KEYS.SESSION, session);
-  }
-  /**
-   * Clear session data
-   */
-  clearSession() {
-    this.safeClearItem(STORAGE_KEYS.SESSION);
-  }
-  // =============================================================================
-  // Anonymous User Data Methods
-  // =============================================================================
-  /**
-   * Get anonymous user data
-   */
-  getAnonymousUserData() {
-    return this.safeGetItem(STORAGE_KEYS.ANONYMOUS_USER);
-  }
-  /**
-   * Set anonymous user data
-   */
-  setAnonymousUserData(data) {
-    return this.safeSetItem(STORAGE_KEYS.ANONYMOUS_USER, data);
-  }
-  /**
-   * Clear anonymous user data
-   */
-  clearAnonymousUserData() {
-    this.safeClearItem(STORAGE_KEYS.ANONYMOUS_USER);
-  }
-  // =============================================================================
-  // Anonymous User ID Methods
-  // =============================================================================
-  /**
-   * Get anonymous user ID
-   */
-  getAnonymousUserId() {
-    if (!this.isLocalStorageAvailable) {
-      return null;
-    }
-    try {
-      return localStorage.getItem("saltfish_anonymous_user_id");
-    } catch (error2) {
-      return null;
-    }
-  }
-  /**
-   * Set anonymous user ID
-   */
-  setAnonymousUserId(userId) {
-    if (!this.isLocalStorageAvailable) {
-      return false;
-    }
-    try {
-      localStorage.setItem("saltfish_anonymous_user_id", userId);
-      return true;
-    } catch (error2) {
-      return false;
-    }
-  }
-  /**
-   * Clear anonymous user ID
-   */
-  clearAnonymousUserId() {
-    if (!this.isLocalStorageAvailable) {
-      return;
-    }
-    try {
-      localStorage.removeItem("saltfish_anonymous_user_id");
-    } catch (error2) {
-    }
-  }
-  // =============================================================================
-  // Utility Methods
-  // =============================================================================
-  /**
-   * Clear all storage data
-   */
-  clearAll() {
-    this.clearProgress();
-    this.clearSession();
-    this.clearAnonymousUserData();
-    this.clearAnonymousUserId();
-  }
-  /**
-   * Get storage availability status
-   */
-  isStorageAvailable() {
-    return this.isLocalStorageAvailable;
-  }
-  /**
-   * Get storage usage information (if available)
-   */
-  getStorageInfo() {
-    const keys = [];
-    if (this.isLocalStorageAvailable) {
-      try {
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
-          if (key && key.startsWith("saltfish_")) {
-            keys.push(key);
-          }
-        }
-      } catch (error2) {
-      }
-    }
-    return {
-      available: this.isLocalStorageAvailable,
-      keys
-    };
-  }
-}
-const storageManager = new StorageManager();
 const createInitialContext = () => ({
   currentStep: null,
   error: null
@@ -1345,7 +1071,7 @@ const saltfishStore = createStore()(
         if (manifest && manifest.steps.some((step) => step.id === stepId)) {
           const targetStep = manifest.steps.find((step) => step.id === stepId);
           set2((state) => {
-            var _a, _b, _c;
+            var _a;
             state.currentStepId = stepId;
             if (targetStep) {
               state.currentState = transitionState({
@@ -1361,11 +1087,6 @@ const saltfishStore = createStore()(
               lastStepId: stepId,
               lastVisited: (/* @__PURE__ */ new Date()).toISOString()
             };
-            const playlistPersistence = ((_b = state.playlistOptions) == null ? void 0 : _b.persistence) ?? true;
-            if (playlistPersistence) {
-              const userId = (_c = state.user) == null ? void 0 : _c.id;
-              storageManager.setProgress(state.progress, userId);
-            }
           });
         }
       },
@@ -1464,7 +1185,6 @@ const saltfishStore = createStore()(
       // New action to update progress when transitioning to completion waiting state
       updateProgressWithCompletion: (playlistId, currentStepId) => {
         set2((state) => {
-          var _a, _b;
           state.currentState = transitionState({ type: "COMPLETE_PLAYLIST_WAITING_FOR_INTERACTION" });
           state.progress[playlistId] = {
             ...state.progress[playlistId],
@@ -1472,11 +1192,6 @@ const saltfishStore = createStore()(
             lastVisited: (/* @__PURE__ */ new Date()).toISOString(),
             completedWaitingForInteraction: true
           };
-          const playlistPersistence = ((_a = state.playlistOptions) == null ? void 0 : _a.persistence) ?? true;
-          if (playlistPersistence) {
-            const userId = (_b = state.user) == null ? void 0 : _b.id;
-            storageManager.setProgress(state.progress, userId);
-          }
         });
       },
       setABTests: (abTests) => {
@@ -1517,6 +1232,37 @@ const useSaltfishStore = {
   subscribe: saltfishStore.subscribe,
   destroy: saltfishStore.destroy
 };
+const STORAGE_KEYS = {
+  PROGRESS: "saltfish_progress",
+  SESSION: "saltfish_session",
+  ANONYMOUS_USER: "saltfish_anonymous_user_data"
+};
+const TIMING = {
+  // 5 seconds
+  STEP_TIMEOUT: 6e4,
+  // Session persistence
+  SESSION_EXPIRY: 30 * 60 * 1e3
+  // 30 minutes in milliseconds
+};
+const API = {
+  BASE_URL: "https://player.saltfish.ai",
+  ENDPOINTS: {
+    VALIDATE_TOKEN: "/validate-token",
+    USERS: "/clients/{token}/users/{userId}"
+  }
+};
+const CSS_CLASSES = {
+  PLAYER: "sf-player",
+  PLAYER_MINIMIZED: "sf-player--minimized",
+  CONTROLS_CONTAINER: "sf-controls-container",
+  LOGO: "sf-player__logo",
+  // Legacy error class
+  ERROR_DISPLAY: "sf-error-display",
+  ERROR_DISPLAY_VISIBLE: "sf-error-display--visible",
+  ERROR_DISPLAY_CONTENT: "sf-error-display__content",
+  ERROR_DISPLAY_MESSAGE: "sf-error-display__message",
+  LOADING_SPINNER: "sf-loading-spinner"
+};
 class ErrorHandler {
   /**
    * Handles an error with consistent logging, reporting, and response
@@ -2524,7 +2270,7 @@ class PlaylistOrchestrator {
    * Start a playlist with given options
    */
   async startPlaylist(playlistId, options) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     try {
       const needsManagerRecreation = this.isInitialized() && !this.managers.uiManager.getPlayerElement();
       if (!this.isInitialized() && this.playerInitializationService) {
@@ -2646,35 +2392,11 @@ class PlaylistOrchestrator {
       }
       this.managers.uiManager.updatePosition();
       store.sendStateMachineEvent({ type: "LOAD_MANIFEST" });
-      const playlistPersistence = options == null ? void 0 : options.persistence;
-      if (typeof window !== "undefined") {
-        const userId = (_d = store.user) == null ? void 0 : _d.id;
-        const progressFromStorage = this.managers.storageManager.getProgress(userId);
-        if (progressFromStorage && progressFromStorage[playlistId]) {
-          store.loadPlaylistProgress(playlistId, progressFromStorage[playlistId]);
-        } else if (store.progress[playlistId]) {
-          log(`PlaylistOrchestrator: Clearing stale progress for ${playlistId} from store.progress`);
-          const cleanedProgress = { ...store.progress };
-          delete cleanedProgress[playlistId];
-          useSaltfishStore.setState((state) => {
-            state.progress = cleanedProgress;
-          });
-        }
-      }
       this.managers.analyticsManager.trackPlaylistStart(playlistId);
       this.managers.cursorManager.resetFirstAnimation();
       log(`[PlaylistOrchestrator.startPlaylist] Using validated manifest path: ${manifestPathToLoad}`);
-      await this.managers.playlistManager.load(manifestPathToLoad, { ...finalOptions, persistence: playlistPersistence });
+      await this.managers.playlistManager.load(manifestPathToLoad, finalOptions);
       const updatedStore = useSaltfishStore.getState();
-      if (updatedStore.manifest) {
-        const manifestPersistence = finalOptions.persistence ?? updatedStore.manifest.isPersistent ?? true;
-        const currentOptions = updatedStore.playlistOptions || {};
-        updatedStore.setPlaylistOptions({
-          ...currentOptions,
-          ...finalOptions,
-          persistence: manifestPersistence
-        });
-      }
       if (finalOptions.startNodeId && updatedStore.manifest) {
         const targetStep = updatedStore.manifest.steps.find((step) => step.id === finalOptions.startNodeId);
         if (targetStep) {
@@ -3097,7 +2819,6 @@ class StateMachineActionHandler {
     }
   }
   handleTrackPlaylistComplete() {
-    var _a, _b;
     const store = useSaltfishStore.getState();
     if (store.manifest && this.managers.eventManager) {
       const playlistId = store.manifest.id;
@@ -3108,13 +2829,6 @@ class StateMachineActionHandler {
           title: store.manifest.name
         }
       });
-      const playlistPersistence = ((_a = store.playlistOptions) == null ? void 0 : _a.persistence) ?? true;
-      if (playlistPersistence && store.progress[playlistId]) {
-        const updatedProgress = { ...store.progress };
-        delete updatedProgress[playlistId];
-        const userId = (_b = store.user) == null ? void 0 : _b.id;
-        this.managers.storageManager.setProgress(updatedProgress, userId);
-      }
     }
   }
   handleError(context) {
@@ -5047,7 +4761,6 @@ class VideoManager {
    * @param url - URL of the video to load
    */
   async loadVideo(url) {
-    var _a;
     const activeVideo = this.getActiveVideo();
     if (!activeVideo) {
       return;
@@ -5064,20 +4777,9 @@ class VideoManager {
       if (this.controls) {
         this.controls.reset();
       }
-      const store2 = useSaltfishStore.getState();
-      const isPersistenceEnabled = ((_a = store2.playlistOptions) == null ? void 0 : _a.persistence) ?? true;
       if (this.currentVideoUrl === url && activeVideo.src && (activeVideo.src === url || activeVideo.src.endsWith(url))) {
-        if (isPersistenceEnabled) {
-          const savedPosition = this.playbackPositions.get(url);
-          if (savedPosition !== void 0 && savedPosition > 0 && Math.abs(activeVideo.currentTime - savedPosition) > 0.5) {
-            activeVideo.currentTime = savedPosition;
-          }
-        }
         return;
       }
-      if (isPersistenceEnabled && this.currentVideoUrl && activeVideo.currentTime > 0) {
-        this.playbackPositions.set(this.currentVideoUrl, activeVideo.currentTime);
-      }
       const inactiveVideo = this.getInactiveVideo();
       if (inactiveVideo && this.nextVideoUrl === url) {
         this.swapVideos();
@@ -5122,18 +4824,10 @@ class VideoManager {
         let loadTimeout;
         const onLoadedData = () => {
           if (!activeVideo) {
-            return;
-          }
-          clearTimeout(loadTimeout);
-          if (isPersistenceEnabled) {
-            const savedPosition = this.playbackPositions.get(url);
-            if (savedPosition !== void 0 && savedPosition > 0) {
-              const safePosition = Math.min(savedPosition, activeVideo.duration - 0.5);
-              activeVideo.currentTime = safePosition;
-            }
-          } else {
-            activeVideo.currentTime = 0;
+            return;
           }
+          clearTimeout(loadTimeout);
+          activeVideo.currentTime = 0;
           this.transcriptManager.updateVideoElement(activeVideo);
           if (this.controls) {
             this.controls.updateVideoElement(activeVideo);
@@ -5222,7 +4916,6 @@ class VideoManager {
    * Plays the video
    */
   play() {
-    var _a;
     const activeVideo = this.getActiveVideo();
     if (!activeVideo) {
       console.error("VideoManager: No active video element found");
@@ -5235,14 +4928,6 @@ class VideoManager {
     if (activeVideo.ended) {
       activeVideo.currentTime = 0;
     }
-    const store = useSaltfishStore.getState();
-    const isPersistenceEnabled = ((_a = store.playlistOptions) == null ? void 0 : _a.persistence) ?? true;
-    if (isPersistenceEnabled && this.currentVideoUrl) {
-      const savedPosition = this.playbackPositions.get(this.currentVideoUrl);
-      if (savedPosition && Math.abs(activeVideo.currentTime - savedPosition) > 0.5) {
-        activeVideo.currentTime = savedPosition;
-      }
-    }
     activeVideo.loop = false;
     if (!activeVideo.paused) {
       if (this.controls) {
@@ -5259,6 +4944,7 @@ class VideoManager {
           this.controls.startProgressTracking();
         }
       } else {
+        const store = useSaltfishStore.getState();
         store.setAutoplayFallback();
         if (this.isMobileDevice()) {
           activeVideo.playsInline = true;
@@ -5274,8 +4960,8 @@ class VideoManager {
       }
     }).catch(() => {
       console.warn("VideoManager: Autoplay handler threw error - browser has strict autoplay policy");
-      const store2 = useSaltfishStore.getState();
-      store2.setAutoplayFallback();
+      const store = useSaltfishStore.getState();
+      store.setAutoplayFallback();
     });
   }
   /**
@@ -6753,7 +6439,6 @@ class InteractionManager {
     __publicField(this, "scrollIndicator", null);
     __publicField(this, "domEventListeners", /* @__PURE__ */ new Map());
     __publicField(this, "storeUnsubscribe", null);
-    __publicField(this, "storageManager", new StorageManager());
     /**
      * Handles the video90PercentReached event
      * @param _event - The custom event dispatched when video reaches 90%
@@ -6973,7 +6658,6 @@ class InteractionManager {
    * @param buttonConfig - The button configuration
    */
   async handleButtonClick(event, buttonConfig) {
-    var _a, _b;
     log(`InteractionManager: Button click detected on button "${buttonConfig.id}"`);
     event.preventDefault();
     event.stopPropagation();
@@ -6998,13 +6682,6 @@ class InteractionManager {
                 };
               }
             });
-            const playlistPersistence = ((_a = currentStore.playlistOptions) == null ? void 0 : _a.persistence) ?? true;
-            if (playlistPersistence) {
-              const userId = (_b = currentStore.user) == null ? void 0 : _b.id;
-              const updatedStore = useSaltfishStore.getState();
-              this.storageManager.setProgress(updatedStore.progress, userId);
-              log(`InteractionManager: Saved progress for step ${buttonConfig.action.target} before URL redirect`);
-            }
           }
           log(`InteractionManager: Redirecting to ${buttonConfig.action.url}`);
           window.location.href = buttonConfig.action.url;
@@ -7522,12 +7199,254 @@ class AnalyticsManager {
     }
   }
 }
+class StorageManager {
+  constructor() {
+    __publicField(this, "isLocalStorageAvailable");
+    this.isLocalStorageAvailable = this.checkLocalStorageAvailability();
+    if (!this.isLocalStorageAvailable) ;
+  }
+  /**
+   * Check if localStorage is available and working
+   */
+  checkLocalStorageAvailability() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    try {
+      const testKey = "__storage_test__";
+      localStorage.setItem(testKey, "test");
+      localStorage.removeItem(testKey);
+      return true;
+    } catch (error2) {
+      return false;
+    }
+  }
+  /**
+   * Safely get an item from localStorage with JSON parsing
+   */
+  safeGetItem(key) {
+    if (!this.isLocalStorageAvailable) {
+      return null;
+    }
+    try {
+      const item = localStorage.getItem(key);
+      if (item === null) {
+        return null;
+      }
+      return JSON.parse(item);
+    } catch (error2) {
+      this.safeClearItem(key);
+      return null;
+    }
+  }
+  /**
+   * Safely set an item in localStorage with JSON stringification
+   */
+  safeSetItem(key, value) {
+    if (!this.isLocalStorageAvailable) {
+      return false;
+    }
+    try {
+      localStorage.setItem(key, JSON.stringify(value));
+      return true;
+    } catch (error2) {
+      if (error2 instanceof DOMException && error2.code === 22) {
+        this.clearOldData();
+        try {
+          localStorage.setItem(key, JSON.stringify(value));
+          return true;
+        } catch (retryError) {
+        }
+      }
+      return false;
+    }
+  }
+  /**
+   * Safely clear an item from localStorage
+   */
+  safeClearItem(key) {
+    if (!this.isLocalStorageAvailable) {
+      return;
+    }
+    try {
+      localStorage.removeItem(key);
+    } catch (error2) {
+    }
+  }
+  /**
+   * Clear old data to free up storage space
+   */
+  clearOldData() {
+    this.safeClearItem(STORAGE_KEYS.SESSION);
+  }
+  // =============================================================================
+  // Progress Data Methods
+  // =============================================================================
+  /**
+   * Get playlist progress data for a specific user
+   * If userId doesn't match stored userId, returns null (stale data)
+   * @param userId - The user ID to validate against stored data
+   */
+  getProgress(userId) {
+    const stored = this.safeGetItem(STORAGE_KEYS.PROGRESS);
+    if (!stored) {
+      return null;
+    }
+    if (userId && stored.userId && stored.userId !== userId) {
+      log(`[StorageManager] Progress belongs to different user (${stored.userId}), ignoring`);
+      return null;
+    }
+    return stored.playlists || null;
+  }
+  /**
+   * Set playlist progress data for a specific user
+   * Clears existing data if userId changes
+   * @param progress - The progress data to save
+   * @param userId - The user ID to associate with this progress
+   */
+  setProgress(progress, userId) {
+    const stored = {
+      userId,
+      playlists: progress
+    };
+    return this.safeSetItem(STORAGE_KEYS.PROGRESS, stored);
+  }
+  /**
+   * Clear all progress data
+   */
+  clearProgress() {
+    this.safeClearItem(STORAGE_KEYS.PROGRESS);
+  }
+  // =============================================================================
+  // Session Data Methods  
+  // =============================================================================
+  /**
+   * Get session data
+   */
+  getSession() {
+    return this.safeGetItem(STORAGE_KEYS.SESSION);
+  }
+  /**
+   * Set session data
+   */
+  setSession(session) {
+    return this.safeSetItem(STORAGE_KEYS.SESSION, session);
+  }
+  /**
+   * Clear session data
+   */
+  clearSession() {
+    this.safeClearItem(STORAGE_KEYS.SESSION);
+  }
+  // =============================================================================
+  // Anonymous User Data Methods
+  // =============================================================================
+  /**
+   * Get anonymous user data
+   */
+  getAnonymousUserData() {
+    return this.safeGetItem(STORAGE_KEYS.ANONYMOUS_USER);
+  }
+  /**
+   * Set anonymous user data
+   */
+  setAnonymousUserData(data) {
+    return this.safeSetItem(STORAGE_KEYS.ANONYMOUS_USER, data);
+  }
+  /**
+   * Clear anonymous user data
+   */
+  clearAnonymousUserData() {
+    this.safeClearItem(STORAGE_KEYS.ANONYMOUS_USER);
+  }
+  // =============================================================================
+  // Anonymous User ID Methods
+  // =============================================================================
+  /**
+   * Get anonymous user ID
+   */
+  getAnonymousUserId() {
+    if (!this.isLocalStorageAvailable) {
+      return null;
+    }
+    try {
+      return localStorage.getItem("saltfish_anonymous_user_id");
+    } catch (error2) {
+      return null;
+    }
+  }
+  /**
+   * Set anonymous user ID
+   */
+  setAnonymousUserId(userId) {
+    if (!this.isLocalStorageAvailable) {
+      return false;
+    }
+    try {
+      localStorage.setItem("saltfish_anonymous_user_id", userId);
+      return true;
+    } catch (error2) {
+      return false;
+    }
+  }
+  /**
+   * Clear anonymous user ID
+   */
+  clearAnonymousUserId() {
+    if (!this.isLocalStorageAvailable) {
+      return;
+    }
+    try {
+      localStorage.removeItem("saltfish_anonymous_user_id");
+    } catch (error2) {
+    }
+  }
+  // =============================================================================
+  // Utility Methods
+  // =============================================================================
+  /**
+   * Clear all storage data
+   */
+  clearAll() {
+    this.clearProgress();
+    this.clearSession();
+    this.clearAnonymousUserData();
+    this.clearAnonymousUserId();
+  }
+  /**
+   * Get storage availability status
+   */
+  isStorageAvailable() {
+    return this.isLocalStorageAvailable;
+  }
+  /**
+   * Get storage usage information (if available)
+   */
+  getStorageInfo() {
+    const keys = [];
+    if (this.isLocalStorageAvailable) {
+      try {
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key && key.startsWith("saltfish_")) {
+            keys.push(key);
+          }
+        }
+      } catch (error2) {
+      }
+    }
+    return {
+      available: this.isLocalStorageAvailable,
+      keys
+    };
+  }
+}
 class SessionManager {
-  constructor(storageManager2) {
+  constructor(storageManager) {
     __publicField(this, "sessionId");
     __publicField(this, "currentRunId", null);
     __publicField(this, "storageManager");
-    this.storageManager = storageManager2 || new StorageManager();
+    this.storageManager = storageManager || new StorageManager();
     this.sessionId = this.getOrCreateSession();
     log(`SessionManager: Initialized with sessionId: ${this.sessionId}`);
   }
@@ -8849,11 +8768,11 @@ class PlaylistLoader {
    * @returns Promise resolving to manifest and determined start step
    */
   async loadManifest(options) {
-    const { manifestPath, playlistOptions, savedProgress } = options;
+    const { manifestPath, playlistOptions } = options;
     try {
       const manifest = await this.fetchManifest(manifestPath);
       this.validateManifest(manifest);
-      const startStepId = this.determineStartStep(manifest, playlistOptions, savedProgress);
+      const startStepId = this.determineStartStep(manifest, playlistOptions);
       log(`PlaylistLoader: Successfully loaded manifest '${manifest.id}' with start step '${startStepId}'`);
       return {
         manifest,
@@ -8939,16 +8858,14 @@ class PlaylistLoader {
     }
   }
   /**
-   * Determines which step to start from based on persistence and saved progress
+   * Determines which step to start from based on options
+   * Note: Persistence has been removed - playlists always start from beginning unless startNodeId is specified
+   * The 4-second rule in PlayerInitializationService handles immediate resume during page transitions
    * @param manifest - The loaded playlist manifest
    * @param options - Playlist configuration options
-   * @param savedProgress - Previously saved progress data
    * @returns The step ID to start from
    */
-  determineStartStep(manifest, options, savedProgress) {
-    var _a;
-    const isPersistenceEnabled = options.persistence ?? manifest.isPersistent ?? true;
-    const manifestIdForProgress = manifest.id;
+  determineStartStep(manifest, options) {
     let startStepId = manifest.startStep;
     if (options.startNodeId) {
       const customStep = manifest.steps.find((step) => step.id === options.startNodeId);
@@ -8958,17 +8875,6 @@ class PlaylistLoader {
       } else {
         log(`PlaylistLoader: Custom start node '${options.startNodeId}' not found, using default start step`);
       }
-    } else if (isPersistenceEnabled && savedProgress && ((_a = savedProgress[manifestIdForProgress]) == null ? void 0 : _a.lastStepId)) {
-      const progressData = savedProgress[manifestIdForProgress];
-      const lastStepId = progressData.lastStepId;
-      if (progressData.completedWaitingForInteraction) {
-        startStepId = manifest.startStep;
-      } else {
-        const savedStep = manifest.steps.find((step) => step.id === lastStepId);
-        if (savedStep) {
-          startStepId = lastStepId;
-        }
-      }
     }
     return startStepId;
   }
@@ -8979,13 +8885,13 @@ class PlaylistManager {
    * @param eventManager - Optional event manager to subscribe to events
    * @param storageManager - Optional storage manager for localStorage operations
    */
-  constructor(eventManager, storageManager2) {
+  constructor(eventManager, storageManager) {
     __publicField(this, "eventManager", null);
     __publicField(this, "isUpdatingWatchedPlaylists", false);
     __publicField(this, "playlistLoader");
     __publicField(this, "storageManager");
     this.playlistLoader = new PlaylistLoader();
-    this.storageManager = storageManager2 || new StorageManager();
+    this.storageManager = storageManager || new StorageManager();
     if (eventManager) {
       this.setEventManager(eventManager);
     }
@@ -10067,13 +9973,13 @@ class ManagerFactory {
    * Create all manager instances with proper dependencies
    */
   createManagers() {
-    const storageManager2 = new StorageManager();
-    const sessionManager = new SessionManager(storageManager2);
+    const storageManager = new StorageManager();
+    const sessionManager = new SessionManager(storageManager);
     const shadowDOMManager = new ShadowDOMManager();
     const videoManager = new VideoManager();
     const eventManager = new EventManager();
     const analyticsManager = new AnalyticsManager(eventManager);
-    const playlistManager = new PlaylistManager(eventManager, storageManager2);
+    const playlistManager = new PlaylistManager(eventManager, storageManager);
     const abTestManager = new ABTestManager(eventManager);
     const cursorManager = new CursorManager();
     const interactionManager = new InteractionManager();
@@ -10097,7 +10003,7 @@ class ManagerFactory {
       playlistManager,
       stepTimeoutManager,
       uiManager,
-      storageManager: storageManager2
+      storageManager
     };
     return managers;
   }
@@ -10318,7 +10224,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.2.50";
+const version = "0.2.52";
 const packageJson = {
   version
 };