saltfish 0.2.52 → 0.2.54

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

@@ -951,6 +951,280 @@ 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
@@ -1071,7 +1345,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;
+            var _a, _b, _c;
             state.currentStepId = stepId;
             if (targetStep) {
               state.currentState = transitionState({
@@ -1087,6 +1361,11 @@ 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);
+            }
           });
         }
       },
@@ -1185,6 +1464,7 @@ 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],
@@ -1192,6 +1472,11 @@ 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) => {
@@ -1232,37 +1517,6 @@ 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
@@ -2270,7 +2524,7 @@ class PlaylistOrchestrator {
    * Start a playlist with given options
    */
   async startPlaylist(playlistId, options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
       const needsManagerRecreation = this.isInitialized() && !this.managers.uiManager.getPlayerElement();
       if (!this.isInitialized() && this.playerInitializationService) {
@@ -2392,11 +2646,35 @@ 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);
+      await this.managers.playlistManager.load(manifestPathToLoad, { ...finalOptions, persistence: playlistPersistence });
       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) {
@@ -2819,6 +3097,7 @@ class StateMachineActionHandler {
     }
   }
   handleTrackPlaylistComplete() {
+    var _a, _b;
     const store = useSaltfishStore.getState();
     if (store.manifest && this.managers.eventManager) {
       const playlistId = store.manifest.id;
@@ -2829,6 +3108,13 @@ 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) {
@@ -4761,6 +5047,7 @@ class VideoManager {
    * @param url - URL of the video to load
    */
   async loadVideo(url) {
+    var _a;
     const activeVideo = this.getActiveVideo();
     if (!activeVideo) {
       return;
@@ -4777,9 +5064,20 @@ 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();
@@ -4826,8 +5124,16 @@ class VideoManager {
           if (!activeVideo) {
             return;
           }
-          clearTimeout(loadTimeout);
-          activeVideo.currentTime = 0;
+          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;
+          }
           this.transcriptManager.updateVideoElement(activeVideo);
           if (this.controls) {
             this.controls.updateVideoElement(activeVideo);
@@ -4916,6 +5222,7 @@ class VideoManager {
    * Plays the video
    */
   play() {
+    var _a;
     const activeVideo = this.getActiveVideo();
     if (!activeVideo) {
       console.error("VideoManager: No active video element found");
@@ -4928,6 +5235,14 @@ 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) {
@@ -4944,7 +5259,6 @@ class VideoManager {
           this.controls.startProgressTracking();
         }
       } else {
-        const store = useSaltfishStore.getState();
         store.setAutoplayFallback();
         if (this.isMobileDevice()) {
           activeVideo.playsInline = true;
@@ -4960,8 +5274,8 @@ class VideoManager {
       }
     }).catch(() => {
       console.warn("VideoManager: Autoplay handler threw error - browser has strict autoplay policy");
-      const store = useSaltfishStore.getState();
-      store.setAutoplayFallback();
+      const store2 = useSaltfishStore.getState();
+      store2.setAutoplayFallback();
     });
   }
   /**
@@ -6439,6 +6753,7 @@ 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%
@@ -6658,6 +6973,7 @@ 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();
@@ -6682,6 +6998,13 @@ 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;
@@ -7199,254 +7522,12 @@ 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(storageManager) {
+  constructor(storageManager2) {
     __publicField(this, "sessionId");
     __publicField(this, "currentRunId", null);
     __publicField(this, "storageManager");
-    this.storageManager = storageManager || new StorageManager();
+    this.storageManager = storageManager2 || new StorageManager();
     this.sessionId = this.getOrCreateSession();
     log(`SessionManager: Initialized with sessionId: ${this.sessionId}`);
   }
@@ -8768,11 +8849,11 @@ class PlaylistLoader {
    * @returns Promise resolving to manifest and determined start step
    */
   async loadManifest(options) {
-    const { manifestPath, playlistOptions } = options;
+    const { manifestPath, playlistOptions, savedProgress } = options;
     try {
       const manifest = await this.fetchManifest(manifestPath);
       this.validateManifest(manifest);
-      const startStepId = this.determineStartStep(manifest, playlistOptions);
+      const startStepId = this.determineStartStep(manifest, playlistOptions, savedProgress);
       log(`PlaylistLoader: Successfully loaded manifest '${manifest.id}' with start step '${startStepId}'`);
       return {
         manifest,
@@ -8858,14 +8939,15 @@ class PlaylistLoader {
     }
   }
   /**
-   * 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
+   * Determines which step to start from based on persistence and saved progress
    * @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) {
+  determineStartStep(manifest, options, savedProgress) {
+    const isPersistenceEnabled = options.persistence ?? manifest.isPersistent ?? true;
+    const manifestIdForProgress = manifest.id;
     let startStepId = manifest.startStep;
     if (options.startNodeId) {
       const customStep = manifest.steps.find((step) => step.id === options.startNodeId);
@@ -8875,6 +8957,19 @@ class PlaylistLoader {
       } else {
         log(`PlaylistLoader: Custom start node '${options.startNodeId}' not found, using default start step`);
       }
+    } else if (isPersistenceEnabled && savedProgress && savedProgress[manifestIdForProgress]) {
+      const progressData = savedProgress[manifestIdForProgress];
+      if (progressData.status === "completed") {
+        startStepId = manifest.startStep;
+      } else {
+        const lastStepId = progressData.currentStepId || progressData.lastStepId;
+        if (lastStepId) {
+          const savedStep = manifest.steps.find((step) => step.id === lastStepId);
+          if (savedStep) {
+            startStepId = lastStepId;
+          }
+        }
+      }
     }
     return startStepId;
   }
@@ -8885,13 +8980,13 @@ class PlaylistManager {
    * @param eventManager - Optional event manager to subscribe to events
    * @param storageManager - Optional storage manager for localStorage operations
    */
-  constructor(eventManager, storageManager) {
+  constructor(eventManager, storageManager2) {
     __publicField(this, "eventManager", null);
     __publicField(this, "isUpdatingWatchedPlaylists", false);
     __publicField(this, "playlistLoader");
     __publicField(this, "storageManager");
     this.playlistLoader = new PlaylistLoader();
-    this.storageManager = storageManager || new StorageManager();
+    this.storageManager = storageManager2 || new StorageManager();
     if (eventManager) {
       this.setEventManager(eventManager);
     }
@@ -8962,7 +9057,8 @@ class PlaylistManager {
       const currentWatchedPlaylists = currentUserData.watchedPlaylists || {};
       const updatedPlaylistData = {
         status,
-        currentStepId: currentStepId || store.currentStepId || null,
+        // Don't save currentStepId for completed playlists - they should restart from beginning
+        currentStepId: status === "completed" ? null : currentStepId || store.currentStepId || null,
         timestamp: Date.now(),
         // Use timestamp for consistency with checkAndResumeInProgressPlaylist
         lastProgressAt: Date.now()
@@ -9042,12 +9138,15 @@ class PlaylistManager {
    * @param options - Playlist configuration options
    */
   async load(playlistId, options) {
+    var _a, _b;
     try {
       const store = useSaltfishStore.getState();
+      const isAnonymous = ((_a = store.user) == null ? void 0 : _a.__isAnonymous) === true;
+      const savedProgress = isAnonymous ? store.progress : ((_b = store.userData) == null ? void 0 : _b.watchedPlaylists) || store.progress;
       const loadResult = await this.playlistLoader.loadManifest({
         manifestPath: playlistId,
         playlistOptions: options,
-        savedProgress: store.progress
+        savedProgress
       });
       const { manifest, startStepId } = loadResult;
       const firstStep = manifest.steps.find((step) => step.id === startStepId);
@@ -9973,13 +10072,13 @@ class ManagerFactory {
    * Create all manager instances with proper dependencies
    */
   createManagers() {
-    const storageManager = new StorageManager();
-    const sessionManager = new SessionManager(storageManager);
+    const storageManager2 = new StorageManager();
+    const sessionManager = new SessionManager(storageManager2);
     const shadowDOMManager = new ShadowDOMManager();
     const videoManager = new VideoManager();
     const eventManager = new EventManager();
     const analyticsManager = new AnalyticsManager(eventManager);
-    const playlistManager = new PlaylistManager(eventManager, storageManager);
+    const playlistManager = new PlaylistManager(eventManager, storageManager2);
     const abTestManager = new ABTestManager(eventManager);
     const cursorManager = new CursorManager();
     const interactionManager = new InteractionManager();
@@ -10003,7 +10102,7 @@ class ManagerFactory {
       playlistManager,
       stepTimeoutManager,
       uiManager,
-      storageManager
+      storageManager: storageManager2
     };
     return managers;
   }
@@ -10224,7 +10323,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.2.52";
+const version = "0.2.54";
 const packageJson = {
   version
 };