@xhub-short/core 0.1.0-beta.9 → 1.0.0-beta.19

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../../node_modules/.pnpm/zustand@5.0.9_@types+react@19.2.7_react@19.2.3/node_modules/zustand/esm/vanilla.mjs
+// ../../node_modules/.pnpm/zustand@5.0.11_@types+react@19.2.14_react@19.2.4/node_modules/zustand/esm/vanilla.mjs
 var createStoreImpl = (createState) => {
   let state;
   const listeners = /* @__PURE__ */ new Set();
@@ -35,6 +35,7 @@ var DEFAULT_FEED_CONFIG = {
 };
 var DEFAULT_PREFETCH_CACHE_CONFIG = {
   enabled: true,
+  maxItems: 10,
   maxVideos: 10,
   storageKey: "sv-prefetch-cache",
   enableDynamicEviction: true,
@@ -54,8 +55,9 @@ var createInitialState = () => ({
   lastFetchTime: null
 });
 var _FeedManager = class _FeedManager {
-  constructor(dataSource, config = {}, storage, prefetchConfig) {
+  constructor(dataSource, config = {}, storage, prefetchConfig, logger) {
     this.dataSource = dataSource;
+    this.logger = logger;
     /** Abort controller for cancelling in-flight requests */
     this.abortController = null;
     /**
@@ -68,6 +70,17 @@ var _FeedManager = class _FeedManager {
      * Used for garbage collection
      */
     this.accessOrder = /* @__PURE__ */ new Map();
+    /**
+     * Track items that have already triggered predictive preload
+     * to avoid duplicate requests.
+     */
+    this.preloadedItemIds = /* @__PURE__ */ new Set();
+    /**
+     * Recommend feed snapshot — preserved when switching to playlist mode.
+     * Stored here (not in React refs) because FeedManager is a singleton
+     * that survives component remounts caused by conditional rendering.
+     */
+    this.recommendSnapshot = null;
     this.config = { ...DEFAULT_FEED_CONFIG, ...config };
     this.prefetchConfig = { ...DEFAULT_PREFETCH_CACHE_CONFIG, ...prefetchConfig };
     this.storage = storage ?? null;
@@ -112,6 +125,25 @@ var _FeedManager = class _FeedManager {
   // ═══════════════════════════════════════════════════════════════
   // PUBLIC API
   // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current data source
+   */
+  getDataSource() {
+    return this.dataSource;
+  }
+  /**
+   * Update data source dynamically
+   * Used for switching between Recommendation and Playlist modes
+   *
+   * @param dataSource - New data source adapter
+   * @param options - Options for state transition
+   */
+  setDataSource(dataSource, options = { reset: true }) {
+    this.dataSource = dataSource;
+    if (options.reset) {
+      this.reset();
+    }
+  }
   /**
    * Load initial feed data
    *
@@ -124,14 +156,14 @@ var _FeedManager = class _FeedManager {
    * - If a request for the same cursor is already in-flight, returns the existing Promise
    * - Prevents duplicate API calls from rapid UI interactions
    */
-  async loadInitial() {
-    if (_FeedManager.globalMemoryCache) {
+  async loadInitial(options) {
+    if (!options?.replace && _FeedManager.globalMemoryCache) {
       const { items, nextCursor } = _FeedManager.globalMemoryCache;
       this.hydrateFromSnapshot(items, nextCursor, { markAsStale: false });
       _FeedManager.globalMemoryCache = null;
       return;
     }
-    const dedupeKey = "__initial__";
+    const dedupeKey = options?.replace ? "__initial_replace__" : "__initial__";
     const existingRequest = this.inFlightRequests.get(dedupeKey);
     if (existingRequest) {
       return existingRequest;
@@ -141,7 +173,7 @@ var _FeedManager = class _FeedManager {
       return;
     }
     this.store.setState({ loading: true, error: null });
-    const request = this.executeLoadInitial();
+    const request = this.executeLoadInitial(options?.replace);
     this.inFlightRequests.set(dedupeKey, request);
     try {
       await request;
@@ -152,9 +184,9 @@ var _FeedManager = class _FeedManager {
   /**
    * Internal: Execute load initial logic
    */
-  async executeLoadInitial() {
+  async executeLoadInitial(replace = false) {
     try {
-      await this.fetchWithRetry();
+      await this.fetchWithRetry(void 0, replace);
       this.updatePrefetchCache();
     } catch (error) {
       this.handleError(error, "loadInitial");
@@ -215,7 +247,7 @@ var _FeedManager = class _FeedManager {
     }
     try {
       const response = await this.dataSource.fetchFeed();
-      this.mergeVideos(response.items, true);
+      this.mergeItems(response.items, true);
       this.store.setState({
         cursor: response.nextCursor,
         hasMore: response.hasMore,
@@ -226,27 +258,50 @@ var _FeedManager = class _FeedManager {
     }
   }
   /**
-   * Get a video by ID
-   * Also updates LRU access time for garbage collection
-   */
-  getVideo(id) {
-    const video = this.store.getState().itemsById.get(id);
-    if (video) {
+   * Handle playback progress and trigger predictive preloading
+   *
+   * @param itemId - ID of the currently playing item
+   * @param progress - Current playback progress (0-1)
+   * @param governor - Resource governor to trigger preload
+   * @param threshold - Progress threshold to trigger preload (default: 0.2)
+   */
+  handlePlaybackProgress(itemId, progress, governor, threshold = 0.2) {
+    if (this.preloadedItemIds.has(itemId)) return;
+    if (progress >= threshold) {
+      this.preloadedItemIds.add(itemId);
+      const state = this.store.getState();
+      const currentIndex = state.displayOrder.indexOf(itemId);
+      if (currentIndex !== -1) {
+        const nextIndices = [currentIndex + 1, currentIndex + 2].filter(
+          (idx) => idx < state.displayOrder.length
+        );
+        if (nextIndices.length > 0) {
+          governor.triggerPreload(nextIndices);
+          this.logger?.debug(
+            `[FeedManager] Predictive preload triggered for indices: ${nextIndices.join(", ")}`
+          );
+        }
+      }
+    }
+  }
+  getItem(id) {
+    const item = this.store.getState().itemsById.get(id);
+    if (item) {
       this.accessOrder.set(id, Date.now());
     }
-    return video;
+    return item;
   }
   /**
-   * Get ordered list of videos
+   * Get ordered list of items
    */
-  getVideos() {
+  getItems() {
     const state = this.store.getState();
     return state.displayOrder.map((id) => state.itemsById.get(id)).filter((v) => v !== void 0);
   }
   /**
-   * Update a video in the feed (for optimistic updates)
+   * Update an item in the feed (for optimistic updates)
    */
-  updateVideo(id, updates) {
+  updateItem(id, updates) {
     const state = this.store.getState();
     const existing = state.itemsById.get(id);
     if (existing) {
@@ -255,6 +310,77 @@ var _FeedManager = class _FeedManager {
       this.store.setState({ itemsById: newItemsById });
     }
   }
+  /**
+   * Replace all items in the feed (e.g. for Playlist synchronization)
+   */
+  replaceItems(items) {
+    const newItemsById = /* @__PURE__ */ new Map();
+    const newDisplayOrder = [];
+    const now = Date.now();
+    for (const item of items) {
+      newItemsById.set(item.id, item);
+      newDisplayOrder.push(item.id);
+      this.accessOrder.set(item.id, now);
+    }
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder,
+      cursor: null,
+      hasMore: false
+    });
+  }
+  /**
+   * @deprecated Use getItem instead
+   */
+  getVideo(id) {
+    return this.getItem(id);
+  }
+  /**
+   * @deprecated Use getItems instead
+   */
+  getVideos() {
+    return this.getItems();
+  }
+  /**
+   * @deprecated Use updateItem instead
+   */
+  updateVideo(id, updates) {
+    this.updateItem(id, updates);
+  }
+  /**
+   * Remove an item from the feed
+   *
+   * Used for:
+   * - Report: Remove reported content from feed
+   * - Not Interested: Remove content user doesn't want to see
+   *
+   * @param id - Content ID to remove
+   * @returns true if item was removed, false if not found
+   *
+   * @example
+   * ```typescript
+   * // User reports a content item
+   * const wasRemoved = feedManager.removeItem(itemId);
+   * if (wasRemoved) {
+   *   // Navigate to next item
+   * }
+   * ```
+   */
+  removeItem(id) {
+    const state = this.store.getState();
+    if (!state.itemsById.has(id)) {
+      return false;
+    }
+    const newItemsById = new Map(state.itemsById);
+    newItemsById.delete(id);
+    const newDisplayOrder = state.displayOrder.filter((itemId) => itemId !== id);
+    this.accessOrder.delete(id);
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder
+    });
+    return true;
+  }
   /**
    * Check if data is stale and needs revalidation
    */
@@ -270,6 +396,7 @@ var _FeedManager = class _FeedManager {
     this.cancelPendingRequests();
     this.inFlightRequests.clear();
     this.accessOrder.clear();
+    this.preloadedItemIds.clear();
     this.store.setState(createInitialState());
   }
   /**
@@ -296,7 +423,7 @@ var _FeedManager = class _FeedManager {
    * Used by LifecycleManager to restore state without API call.
    * This bypasses normal data flow for state restoration.
    *
-   * @param items - Video items from snapshot
+   * @param items - Content items from snapshot
    * @param cursor - Pagination cursor from snapshot
    * @param options - Additional hydration options
    */
@@ -307,10 +434,10 @@ var _FeedManager = class _FeedManager {
     const now = Date.now();
     const newItemsById = /* @__PURE__ */ new Map();
     const newDisplayOrder = [];
-    for (const video of items) {
-      newItemsById.set(video.id, video);
-      newDisplayOrder.push(video.id);
-      this.accessOrder.set(video.id, now);
+    for (const item of items) {
+      newItemsById.set(item.id, item);
+      newDisplayOrder.push(item.id);
+      this.accessOrder.set(item.id, now);
     }
     this.store.setState({
       itemsById: newItemsById,
@@ -325,26 +452,67 @@ var _FeedManager = class _FeedManager {
     });
   }
   // ═══════════════════════════════════════════════════════════════
+  // RECOMMEND SNAPSHOT (for playlist ↔ recommend switching)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Save the current recommend feed state before switching to playlist mode.
+   *
+   * @param activeIndex - Current scroll position (active item index)
+   */
+  saveRecommendSnapshot(activeIndex) {
+    this.recommendSnapshot = {
+      items: this.getItems(),
+      cursor: this.store.getState().cursor,
+      hasMore: this.store.getState().hasMore,
+      activeIndex
+    };
+  }
+  /**
+   * Restore the recommend feed state after exiting playlist mode.
+   * Delegates to hydrateFromSnapshot() internally to avoid duplicating hydration logic.
+   *
+   * @returns The saved activeIndex, or null if no snapshot was available
+   */
+  restoreRecommendSnapshot() {
+    const snapshot = this.recommendSnapshot;
+    if (!snapshot || snapshot.items.length === 0) {
+      this.recommendSnapshot = null;
+      return null;
+    }
+    this.hydrateFromSnapshot(snapshot.items, snapshot.cursor, {
+      markAsStale: false
+    });
+    const savedIndex = snapshot.activeIndex;
+    this.recommendSnapshot = null;
+    return savedIndex;
+  }
+  /**
+   * Check if a recommend snapshot exists (for conditional logic in hooks)
+   */
+  hasRecommendSnapshot() {
+    return this.recommendSnapshot !== null && this.recommendSnapshot.items.length > 0;
+  }
+  // ═══════════════════════════════════════════════════════════════
   // PREFETCH CACHE METHODS
   // ═══════════════════════════════════════════════════════════════
   /**
    * Update prefetch cache with current feed tail
    * Called automatically after loadInitial() and loadMore()
    *
-   * Strategy: Cache the LAST N videos (tail of feed)
-   * These are videos user hasn't seen yet, perfect for instant display
+   * Strategy: Cache the LAST N items (tail of feed)
+   * These are items user hasn't seen yet, perfect for instant display
    */
   updatePrefetchCache() {
     if (!this.prefetchConfig.enabled) return;
     if (!this.storage) return;
     const state = this.store.getState();
-    const allVideos = this.getVideos();
-    if (allVideos.length < this.prefetchConfig.maxVideos) {
+    const allItems = this.getItems();
+    if (allItems.length < this.prefetchConfig.maxItems) {
       return;
     }
-    const tailVideos = allVideos.slice(-this.prefetchConfig.maxVideos);
+    const tailItems = allItems.slice(-this.prefetchConfig.maxItems);
     const cacheData = {
-      items: tailVideos,
+      items: tailItems,
       savedAt: Date.now(),
       cursor: state.cursor
     };
@@ -387,6 +555,35 @@ var _FeedManager = class _FeedManager {
       // Trigger revalidation
     });
   }
+  /**
+   * Load prefetch cache synchronously (zero-flash optimization)
+   *
+   * Uses `storage.getSync()` for synchronous localStorage access.
+   * This allows hydrating the feed during React's synchronous render phase,
+   * preventing any flash of loading/empty state when cached data exists.
+   *
+   * Returns null if:
+   * - Prefetch cache is disabled
+   * - No storage adapter
+   * - Storage doesn't support sync reads (e.g., IndexedDB)
+   * - No cached data
+   *
+   * @returns Cached feed data or null
+   */
+  loadPrefetchCacheSync() {
+    if (!this.prefetchConfig.enabled) return null;
+    if (!this.storage) return null;
+    if (!this.storage.getSync) return null;
+    try {
+      const data = this.storage.getSync(this.prefetchConfig.storageKey);
+      if (!data || !data.items || data.items.length === 0) {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Clear prefetch cache
    * Call when user logs out or data should be invalidated
@@ -399,26 +596,26 @@ var _FeedManager = class _FeedManager {
     }
   }
   /**
-   * Evict videos that user has scrolled past from prefetch cache
+   * Evict items that user has scrolled past from prefetch cache
    * Called when user's focusedIndex changes
    *
-   * Strategy: Remove all videos at or before current position
-   * This ensures user doesn't rewatch videos on reload
+   * Strategy: Remove all items at or before current position
+   * This ensures user doesn't rewatch items on reload
    *
-   * @param currentIndex - Current focused video index in feed
+   * @param currentIndex - Current focused item index in feed
    */
-  async evictViewedVideosFromCache(currentIndex) {
+  async evictViewedItemsFromCache(currentIndex) {
     if (!this.prefetchConfig.enabled) return;
     if (!this.prefetchConfig.enableDynamicEviction) return;
     if (!this.storage) return;
     try {
       const cache = await this.loadPrefetchCache();
       if (!cache || cache.items.length === 0) return;
-      const allVideos = this.getVideos();
-      const currentVideo = allVideos[currentIndex];
-      if (!currentVideo) return;
-      const viewedVideoIds = new Set(allVideos.slice(0, currentIndex + 1).map((v) => v.id));
-      const updatedItems = cache.items.filter((item) => !viewedVideoIds.has(item.id));
+      const allItems = this.getItems();
+      const currentItem = allItems[currentIndex];
+      if (!currentItem) return;
+      const viewedItemIds = new Set(allItems.slice(0, currentIndex + 1).map((v) => v.id));
+      const updatedItems = cache.items.filter((item) => !viewedItemIds.has(item.id));
       if (updatedItems.length === cache.items.length) return;
       if (updatedItems.length === 0) {
         await this.storage.remove(this.prefetchConfig.storageKey);
@@ -445,13 +642,17 @@ var _FeedManager = class _FeedManager {
   /**
    * Fetch with exponential backoff retry
    */
-  async fetchWithRetry(cursor) {
+  async fetchWithRetry(cursor, replace = false) {
     let lastError = null;
     for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
       try {
         this.abortController = new AbortController();
         const response = await this.dataSource.fetchFeed(cursor);
-        this.addVideos(response.items);
+        if (replace) {
+          this.replaceItems(response.items);
+        } else {
+          this.addItems(response.items);
+        }
         this.store.setState({
           cursor: response.nextCursor,
           hasMore: response.hasMore,
@@ -474,20 +675,23 @@ var _FeedManager = class _FeedManager {
     throw lastError;
   }
   /**
-   * Add videos with deduplication
+   * Add items with deduplication
    * Triggers garbage collection if cache exceeds maxCacheSize
    */
-  addVideos(videos) {
+  addItems(items) {
     const state = this.store.getState();
     const newItemsById = new Map(state.itemsById);
     const newDisplayOrder = [...state.displayOrder];
     const now = Date.now();
-    for (const video of videos) {
-      if (!newItemsById.has(video.id)) {
-        newItemsById.set(video.id, video);
-        newDisplayOrder.push(video.id);
-        this.accessOrder.set(video.id, now);
+    for (const item of items) {
+      const existing = newItemsById.get(item.id);
+      if (existing) {
+        newItemsById.set(item.id, { ...existing, ...item });
+      } else {
+        newItemsById.set(item.id, item);
+        newDisplayOrder.push(item.id);
       }
+      this.accessOrder.set(item.id, now);
     }
     this.store.setState({
       itemsById: newItemsById,
@@ -498,19 +702,19 @@ var _FeedManager = class _FeedManager {
     }
   }
   /**
-   * Merge videos (for SWR revalidation)
-   * Updates existing videos, adds new ones at the beginning
+   * Merge items (for SWR revalidation)
+   * Updates existing items, adds new ones at the beginning
    */
-  mergeVideos(videos, prepend) {
+  mergeItems(items, prepend) {
     const state = this.store.getState();
     const newItemsById = new Map(state.itemsById);
     const newIds = [];
-    for (const video of videos) {
-      if (newItemsById.has(video.id)) {
-        newItemsById.set(video.id, video);
+    for (const item of items) {
+      if (newItemsById.has(item.id)) {
+        newItemsById.set(item.id, item);
       } else {
-        newItemsById.set(video.id, video);
-        newIds.push(video.id);
+        newItemsById.set(item.id, item);
+        newIds.push(item.id);
       }
     }
     const newDisplayOrder = prepend ? [...newIds, ...state.displayOrder] : [...state.displayOrder, ...newIds];
@@ -583,9 +787,9 @@ var _FeedManager = class _FeedManager {
    * Run garbage collection using LRU (Least Recently Used) policy
    *
    * When cache size exceeds maxCacheSize:
-   * 1. Sort videos by last access time (oldest first)
-   * 2. Evict oldest videos until cache is within limit
-   * 3. Keep videos that are currently in viewport (most recent in displayOrder)
+   * 1. Sort items by last access time (oldest first)
+   * 2. Evict oldest items until cache is within limit
+   * 3. Keep items that are currently in viewport (most recent in displayOrder)
    *
    * @returns Number of evicted items
    */
@@ -811,7 +1015,9 @@ var PlayerEngine = class {
       loopCount: 0,
       watchTime: 0,
       error: null,
-      ended: false
+      ended: false,
+      playbackRate: this.store.getState().playbackRate
+      // Persist speed across videos (AC 5)
     });
     this.emitEvent({ type: "videoChange", video });
     this.logger?.debug(`[PlayerEngine] Loaded video: ${video.id}`);
@@ -1653,25 +1859,7 @@ var LifecycleManager = class {
     this.store.setState({ isSaving: true });
     this.emitEvent({ type: "saveStart" });
     try {
-      const snapshot = {
-        items: data.items,
-        cursor: data.cursor,
-        focusedIndex: data.focusedIndex,
-        scrollPosition: data.scrollPosition,
-        savedAt: Date.now(),
-        version: this.config.version
-      };
-      if (this.config.restorePlaybackPosition) {
-        if (data.playbackTime !== void 0) {
-          snapshot.playbackTime = data.playbackTime;
-        }
-        if (data.currentVideoId !== void 0) {
-          snapshot.currentVideoId = data.currentVideoId;
-        }
-        if (data.restoreFrame !== void 0) {
-          snapshot.restoreFrame = data.restoreFrame;
-        }
-      }
+      const snapshot = this.createSnapshot(data);
       await this.storage.saveSnapshot(snapshot);
       const timestamp = Date.now();
       this.store.setState({
@@ -1812,6 +2000,25 @@ var LifecycleManager = class {
   isSnapshotStale(snapshot) {
     return Date.now() - snapshot.savedAt > this.config.revalidationThresholdMs;
   }
+  /**
+   * Create session snapshot from data
+   */
+  createSnapshot(data) {
+    const snapshot = {
+      items: data.items,
+      cursor: data.cursor,
+      focusedIndex: data.focusedIndex,
+      scrollPosition: data.scrollPosition,
+      savedAt: Date.now(),
+      version: this.config.version
+    };
+    if (this.config.restorePlaybackPosition) {
+      if (data.playbackTime !== void 0) snapshot.playbackTime = data.playbackTime;
+      if (data.currentVideoId !== void 0) snapshot.currentVideoId = data.currentVideoId;
+      if (data.restoreFrame !== void 0) snapshot.restoreFrame = data.restoreFrame;
+    }
+    return snapshot;
+  }
   /**
    * Emit event to all listeners
    */
@@ -2360,39 +2567,47 @@ var ResourceGovernor = class {
       newPreloadingIndices.add(index);
     }
     this.store.setState({ preloadingIndices: newPreloadingIndices });
-    const preloadPromises = indicesToPreload.map(async (index) => {
-      const videoInfo = this.videoSourceGetter?.(index);
-      if (!videoInfo) return;
-      try {
+    const maxParallel = 2;
+    const executeInBatches = async () => {
+      for (let i = 0; i < indicesToPreload.length; i += maxParallel) {
+        const batch = indicesToPreload.slice(i, i + maxParallel);
+        await Promise.allSettled(batch.map((index) => this.preloadOne(index, indicesToPreload)));
+      }
+    };
+    await executeInBatches();
+  }
+  /**
+   * Internal helper to preload a single video
+   */
+  async preloadOne(index, indicesToPreload) {
+    const videoInfo = this.videoSourceGetter?.(index);
+    if (!videoInfo) return;
+    try {
+      this.logger?.debug(`[ResourceGovernor] Preloading video at index ${index} (${videoInfo.id})`);
+      const result = await this.videoLoader?.preload(videoInfo.id, videoInfo.source, {
+        priority: indicesToPreload.indexOf(index)
+        // Lower index = higher priority
+      });
+      if (result?.status === "ready") {
         this.logger?.debug(
-          `[ResourceGovernor] Preloading video at index ${index} (${videoInfo.id})`
+          `[ResourceGovernor] Preload complete for index ${index} (${result.loadedBytes ?? 0} bytes)`
         );
-        const result = await this.videoLoader?.preload(videoInfo.id, videoInfo.source, {
-          priority: indicesToPreload.indexOf(index)
-          // Lower index = higher priority
-        });
-        if (result?.status === "ready") {
-          this.logger?.debug(
-            `[ResourceGovernor] Preload complete for index ${index} (${result.loadedBytes ?? 0} bytes)`
-          );
-        } else if (result?.status === "error") {
-          this.logger?.warn(
-            `[ResourceGovernor] Preload failed for index ${index}: ${result.error?.message}`
-          );
-        }
-      } catch (err) {
-        this.logger?.error(
-          "[ResourceGovernor] Preload error",
-          err instanceof Error ? err : new Error(String(err))
+      } else if (result?.status === "error") {
+        this.logger?.warn(
+          `[ResourceGovernor] Preload failed for index ${index}: ${result.error?.message}`
         );
-      } finally {
-        const currentState = this.store.getState();
-        const updatedPreloadingIndices = new Set(currentState.preloadingIndices);
-        updatedPreloadingIndices.delete(index);
-        this.store.setState({ preloadingIndices: updatedPreloadingIndices });
       }
-    });
-    await Promise.allSettled(preloadPromises);
+    } catch (err) {
+      this.logger?.error(
+        "[ResourceGovernor] Preload error",
+        err instanceof Error ? err : new Error(String(err))
+      );
+    } finally {
+      const currentState = this.store.getState();
+      const updatedPreloadingIndices = new Set(currentState.preloadingIndices);
+      updatedPreloadingIndices.delete(index);
+      this.store.setState({ preloadingIndices: updatedPreloadingIndices });
+    }
   }
   /**
    * Execute poster preloading for given indices
@@ -2453,8 +2668,10 @@ var OptimisticManager = class {
     this.eventListeners = /* @__PURE__ */ new Set();
     /** Retry timer */
     this.retryTimer = null;
-    /** Debounce timers for like/unlike per video */
+    /** Debounce timers for like/unlike per item */
     this.likeDebounceTimers = /* @__PURE__ */ new Map();
+    /** Intended like state while debouncing (itemId -> isLiked) */
+    this.intendedLikeState = /* @__PURE__ */ new Map();
     /** Debounce delay in ms */
     this.debounceDelay = 300;
     const { interaction, feedManager, logger, ...restConfig } = config;
@@ -2468,453 +2685,353 @@ var OptimisticManager = class {
   // PUBLIC API - ACTIONS
   // ═══════════════════════════════════════════════════════════════
   /**
-   * Like a video with optimistic update
+   * Like an item with optimistic update
    */
-  async like(videoId) {
-    return this.performAction("like", videoId, async () => {
+  async like(itemId) {
+    return this.performAction("like", itemId, async () => {
       if (!this.interaction) throw new Error("No interaction adapter");
-      await this.interaction.like(videoId);
+      await this.interaction.like(itemId);
     });
   }
   /**
-   * Unlike a video with optimistic update
+   * Unlike an item with optimistic update
    */
-  async unlike(videoId) {
-    return this.performAction("unlike", videoId, async () => {
+  async unlike(itemId) {
+    return this.performAction("unlike", itemId, async () => {
       if (!this.interaction) throw new Error("No interaction adapter");
-      await this.interaction.unlike(videoId);
+      await this.interaction.unlike(itemId);
     });
   }
   /**
-   * Toggle like state with DEBOUNCE (like if not liked, unlike if liked)
-   *
-   * This method:
-   * 1. Updates UI immediately (optimistic)
-   * 2. Debounces API call - only sends after user stops clicking
-   * 3. Sends final state to API after debounce delay
-   *
-   * Perfect for rapid tapping like TikTok/Instagram behavior.
+   * Toggle like state with DEBOUNCE
    */
-  toggleLike(videoId) {
-    const video = this.feedManager?.getVideo(videoId);
-    if (!video) {
-      this.logger?.warn(`[OptimisticManager] Video not found: ${videoId}`);
+  toggleLike(itemId) {
+    const item = this.feedManager?.getItem(itemId);
+    if (!item) {
+      this.logger?.warn(`[OptimisticManager] Item not found for toggleLike: ${itemId}`);
       return;
     }
-    const newIsLiked = !video.isLiked;
+    const currentIntended = this.intendedLikeState.get(itemId) ?? item.isLiked;
+    const newIsLiked = !currentIntended;
+    this.intendedLikeState.set(itemId, newIsLiked);
     const likeDelta = newIsLiked ? 1 : -1;
-    this.feedManager?.updateVideo(videoId, {
+    const currentLikesFromStore = item.stats.likes;
+    this.feedManager?.updateItem(itemId, {
       isLiked: newIsLiked,
-      stats: { ...video.stats, likes: Math.max(0, video.stats.likes + likeDelta) }
+      stats: { ...item.stats, likes: Math.max(0, currentLikesFromStore + likeDelta) }
     });
-    this.logger?.debug(`[OptimisticManager] UI updated: ${videoId} isLiked=${newIsLiked}`);
-    const existingTimer = this.likeDebounceTimers.get(videoId);
+    const actionId = `like-debounce-${itemId}`;
+    this.store.setState((state) => {
+      const pendingActions = new Map(state.pendingActions);
+      pendingActions.set(actionId, {
+        id: actionId,
+        videoId: itemId,
+        // Keep property name 'videoId' in PendingAction for compatibility if needed, but using itemId value
+        type: newIsLiked ? "like" : "unlike",
+        status: "pending",
+        timestamp: Date.now(),
+        retryCount: 0,
+        rollbackData: {
+          isLiked: currentIntended,
+          stats: { ...item.stats }
+        }
+        // Cast back to VideoItem if needed for contract
+      });
+      return { pendingActions, hasPending: true };
+    });
+    const existingTimer = this.likeDebounceTimers.get(itemId);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
     const timer = setTimeout(() => {
-      this.likeDebounceTimers.delete(videoId);
-      this.executeDebouncedLikeApi(videoId);
+      this.likeDebounceTimers.delete(itemId);
+      this.executeDebouncedLikeApi(itemId, actionId);
     }, this.debounceDelay);
-    this.likeDebounceTimers.set(videoId, timer);
+    this.likeDebounceTimers.set(itemId, timer);
   }
   /**
-   * Execute the actual API call after debounce
-   * Reads current state from FeedManager to get final intended state
+   * Execute API call after debounce delay
    */
-  async executeDebouncedLikeApi(videoId) {
-    const video = this.feedManager?.getVideo(videoId);
-    if (!video) return;
-    const shouldLike = video.isLiked;
-    this.logger?.debug(`[OptimisticManager] Debounce fired: ${videoId} shouldLike=${shouldLike}`);
+  async executeDebouncedLikeApi(itemId, actionId) {
+    const finalIntended = this.intendedLikeState.get(itemId);
+    if (finalIntended === void 0) {
+      this.removePendingAction(actionId);
+      return;
+    }
     try {
-      if (!this.interaction) {
-        throw new Error("No interaction adapter");
-      }
-      if (shouldLike) {
-        await this.interaction.like(videoId);
+      if (!this.interaction) throw new Error("No interaction adapter");
+      if (finalIntended) {
+        await this.interaction.like(itemId);
       } else {
-        await this.interaction.unlike(videoId);
+        await this.interaction.unlike(itemId);
+      }
+      if (this.intendedLikeState.get(itemId) === finalIntended) {
+        this.intendedLikeState.delete(itemId);
       }
-      this.logger?.debug(
-        `[OptimisticManager] API success: ${videoId} ${shouldLike ? "liked" : "unliked"}`
-      );
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger?.warn(`[OptimisticManager] API failed: ${videoId}`, { error: err.message });
-      const currentVideo = this.feedManager?.getVideo(videoId);
-      if (currentVideo) {
-        const rollbackIsLiked = !shouldLike;
+      this.handleDebouncedApiError(itemId, finalIntended, error);
+    } finally {
+      this.removePendingAction(actionId);
+    }
+  }
+  /**
+   * Handle errors from debounced API calls
+   */
+  handleDebouncedApiError(itemId, finalIntended, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    this.logger?.error(`[OptimisticManager] API failed for ${itemId}`, err);
+    if (!this.intendedLikeState.has(itemId)) {
+      const currentItem = this.feedManager?.getItem(itemId);
+      if (currentItem) {
+        const rollbackIsLiked = !finalIntended;
         const rollbackDelta = rollbackIsLiked ? 1 : -1;
-        this.feedManager?.updateVideo(videoId, {
+        this.feedManager?.updateItem(itemId, {
           isLiked: rollbackIsLiked,
           stats: {
-            ...currentVideo.stats,
-            likes: Math.max(0, currentVideo.stats.likes + rollbackDelta)
+            ...currentItem.stats,
+            likes: Math.max(0, currentItem.stats.likes + rollbackDelta)
           }
         });
-        this.logger?.debug(
-          `[OptimisticManager] Rolled back: ${videoId} isLiked=${rollbackIsLiked}`
-        );
       }
     }
   }
   /**
-   * @deprecated Use toggleLike() instead - it now includes debounce
-   * Legacy toggle that waits for API response
+   * Remove a pending action by ID
    */
-  async toggleLikeSync(videoId) {
-    const video = this.feedManager?.getVideo(videoId);
-    if (!video) {
-      this.logger?.warn(`[OptimisticManager] Video not found: ${videoId}`);
-      return false;
-    }
-    return video.isLiked ? this.unlike(videoId) : this.like(videoId);
+  removePendingAction(actionId) {
+    this.store.setState((state) => {
+      const pendingActions = new Map(state.pendingActions);
+      pendingActions.delete(actionId);
+      return {
+        pendingActions,
+        hasPending: pendingActions.size > 0
+      };
+    });
   }
   /**
-   * Follow a video author with optimistic update
+   * Toggle follow state
    */
-  async follow(videoId) {
-    return this.performAction("follow", videoId, async () => {
+  async toggleFollow(itemId) {
+    const item = this.feedManager?.getItem(itemId);
+    if (!item) return false;
+    return item.isFollowing ? this.unfollow(itemId) : this.follow(itemId);
+  }
+  async follow(itemId) {
+    return this.performAction("follow", itemId, async () => {
       if (!this.interaction) throw new Error("No interaction adapter");
-      await this.interaction.follow(videoId);
+      await this.interaction.follow(itemId);
     });
   }
-  /**
-   * Unfollow a video author with optimistic update
-   */
-  async unfollow(videoId) {
-    return this.performAction("unfollow", videoId, async () => {
+  async unfollow(itemId) {
+    return this.performAction("unfollow", itemId, async () => {
       if (!this.interaction) throw new Error("No interaction adapter");
-      await this.interaction.unfollow(videoId);
+      await this.interaction.unfollow(itemId);
     });
   }
+  addEventListener(listener) {
+    this.eventListeners.add(listener);
+    return () => this.removeEventListener(listener);
+  }
+  removeEventListener(listener) {
+    this.eventListeners.delete(listener);
+  }
   /**
-   * Toggle follow state
+   * Reset all optimistic state
    */
-  async toggleFollow(videoId) {
-    const video = this.feedManager?.getVideo(videoId);
-    if (!video) {
-      this.logger?.warn(`[OptimisticManager] Video not found: ${videoId}`);
-      return false;
-    }
-    return video.isFollowing ? this.unfollow(videoId) : this.follow(videoId);
+  reset() {
+    this.store.setState(createInitialState5());
   }
   // ═══════════════════════════════════════════════════════════════
-  // PUBLIC API - STATE MANAGEMENT
+  // STATE MANAGEMENT
   // ═══════════════════════════════════════════════════════════════
-  /**
-   * Get all pending actions
-   */
   getPendingActions() {
     return [...this.store.getState().pendingActions.values()];
   }
-  /**
-   * Check if there's a pending action for a video
-   * Only returns true for actions with status 'pending' (not 'failed')
-   */
-  hasPendingAction(videoId, type) {
+  hasPendingAction(itemId, type) {
     const actions = this.store.getState().pendingActions;
     for (const action of actions.values()) {
-      if (action.videoId === videoId && action.status === "pending" && (!type || action.type === type)) {
+      if (action.videoId === itemId && action.status === "pending" && (!type || action.type === type)) {
         return true;
       }
     }
     return false;
   }
-  /**
-   * Get failed actions queue
-   */
   getFailedQueue() {
     const state = this.store.getState();
     return state.failedQueue.map((id) => state.pendingActions.get(id)).filter((a) => a !== void 0);
   }
-  /**
-   * Manually retry failed actions
-   */
   async retryFailed() {
     const state = this.store.getState();
     if (state.isRetrying || state.failedQueue.length === 0) return;
     this.store.setState({ isRetrying: true });
-    const failedQueue = [...state.failedQueue];
-    for (const actionId of failedQueue) {
-      const action = state.pendingActions.get(actionId);
-      if (action && action.retryCount < this.config.maxRetries) {
+    const queue = [...state.failedQueue];
+    for (const id of queue) {
+      const action = this.store.getState().pendingActions.get(id);
+      if (!action) continue;
+      if (action.retryCount < this.config.maxRetries) {
         await this.retryAction(action);
+      } else {
+        this.emit({ type: "retryExhausted", action });
       }
     }
     this.store.setState({ isRetrying: false });
   }
-  /**
-   * Clear all failed actions
-   */
   clearFailed() {
     const state = this.store.getState();
-    const newPendingActions = new Map(state.pendingActions);
-    for (const actionId of state.failedQueue) {
-      const action = newPendingActions.get(actionId);
+    const newPending = new Map(state.pendingActions);
+    for (const id of state.failedQueue) {
+      const action = newPending.get(id);
       if (action) {
         this.applyRollback(action);
-        newPendingActions.delete(actionId);
+        newPending.delete(id);
       }
     }
     this.store.setState({
-      pendingActions: newPendingActions,
+      pendingActions: newPending,
       failedQueue: [],
-      hasPending: newPendingActions.size > 0
+      hasPending: newPending.size > 0
     });
   }
-  // ═══════════════════════════════════════════════════════════════
-  // PUBLIC API - LIFECYCLE
-  // ═══════════════════════════════════════════════════════════════
-  /**
-   * Reset manager state
-   */
-  reset() {
-    this.cancelRetryTimer();
-    this.store.setState(createInitialState5());
-  }
-  /**
-   * Destroy manager and cleanup
-   */
   destroy() {
-    this.cancelRetryTimer();
+    if (this.retryTimer) clearTimeout(this.retryTimer);
     this.eventListeners.clear();
-    this.store.setState(createInitialState5());
-  }
-  // ═══════════════════════════════════════════════════════════════
-  // PUBLIC API - EVENTS
-  // ═══════════════════════════════════════════════════════════════
-  /**
-   * Add event listener
-   */
-  addEventListener(listener) {
-    this.eventListeners.add(listener);
-    return () => this.eventListeners.delete(listener);
-  }
-  /**
-   * Remove event listener
-   */
-  removeEventListener(listener) {
-    this.eventListeners.delete(listener);
   }
   // ═══════════════════════════════════════════════════════════════
-  // PRIVATE METHODS
+  // PRIVATE UTILS
   // ═══════════════════════════════════════════════════════════════
-  /**
-   * Perform an optimistic action
-   */
-  async performAction(type, videoId, apiCall) {
-    if (this.hasPendingAction(videoId, type)) {
-      this.logger?.debug(`[OptimisticManager] Duplicate action skipped: ${type} ${videoId}`);
-      return false;
+  emit(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.logger?.error("[OptimisticManager] Listener failed", error);
+      }
     }
-    const video = this.feedManager?.getVideo(videoId);
-    if (!video) {
-      this.logger?.warn(`[OptimisticManager] Video not found: ${videoId}`);
+  }
+  async performAction(type, itemId, apiCall) {
+    const item = this.feedManager?.getItem(itemId);
+    if (!item) return false;
+    if (this.hasPendingAction(itemId, type)) {
       return false;
     }
     const action = {
       id: generateActionId(),
       type,
-      videoId,
-      rollbackData: this.createRollbackData(type, video),
+      videoId: itemId,
+      rollbackData: this.createRollbackData(type, item),
       timestamp: Date.now(),
       status: "pending",
       retryCount: 0
     };
     this.addPendingAction(action);
-    this.emitEvent({ type: "actionStart", action });
-    this.applyOptimisticUpdate(type, video);
-    this.logger?.debug(`[OptimisticManager] Action started: ${type} ${videoId}`);
+    this.applyOptimisticUpdate(type, item);
+    this.emit({ type: "actionStart", action });
     try {
       await apiCall();
       this.markActionSuccess(action.id);
-      this.emitEvent({ type: "actionSuccess", action: { ...action, status: "success" } });
-      this.logger?.debug(`[OptimisticManager] Action succeeded: ${type} ${videoId}`);
       return true;
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       this.markActionFailed(action.id, err.message);
       this.applyRollback(action);
-      this.emitEvent({ type: "actionRollback", action: { ...action, status: "failed" } });
-      this.emitEvent({ type: "actionFailed", action: { ...action, status: "failed" }, error: err });
-      this.logger?.warn(`[OptimisticManager] Action failed: ${type} ${videoId}`, {
-        error: err.message
-      });
-      if (this.config.autoRetry) {
-        this.scheduleRetry();
-      }
+      if (this.config.autoRetry) this.scheduleRetry();
       return false;
     }
   }
-  /**
-   * Create rollback data based on action type
-   */
-  createRollbackData(type, video) {
-    switch (type) {
-      case "like":
-        return {
-          isLiked: video.isLiked,
-          stats: { ...video.stats }
-        };
-      case "unlike":
-        return {
-          isLiked: video.isLiked,
-          stats: { ...video.stats }
-        };
-      case "follow":
-      case "unfollow":
-        return {
-          isFollowing: video.isFollowing
-        };
-      default:
-        return {};
+  createRollbackData(type, item) {
+    if (type === "like" || type === "unlike") {
+      return { isLiked: item.isLiked, stats: { ...item.stats } };
     }
+    return { isFollowing: item.isFollowing };
   }
-  /**
-   * Apply optimistic update to feed
-   */
-  applyOptimisticUpdate(type, video) {
+  applyOptimisticUpdate(type, item) {
     if (!this.feedManager) return;
-    switch (type) {
-      case "like":
-        this.feedManager.updateVideo(video.id, {
-          isLiked: true,
-          stats: { ...video.stats, likes: video.stats.likes + 1 }
-        });
-        break;
-      case "unlike":
-        this.feedManager.updateVideo(video.id, {
-          isLiked: false,
-          stats: { ...video.stats, likes: Math.max(0, video.stats.likes - 1) }
-        });
-        break;
-      case "follow":
-        this.feedManager.updateVideo(video.id, {
-          isFollowing: true
-        });
-        break;
-      case "unfollow":
-        this.feedManager.updateVideo(video.id, {
-          isFollowing: false
-        });
-        break;
+    if (type === "like") {
+      this.feedManager.updateItem(item.id, {
+        isLiked: true,
+        stats: { ...item.stats, likes: item.stats.likes + 1 }
+      });
+    } else if (type === "unlike") {
+      this.feedManager.updateItem(item.id, {
+        isLiked: false,
+        stats: { ...item.stats, likes: Math.max(0, item.stats.likes - 1) }
+      });
+    } else if (type === "follow") {
+      this.feedManager.updateItem(item.id, { isFollowing: true });
+    } else if (type === "unfollow") {
+      this.feedManager.updateItem(item.id, { isFollowing: false });
     }
   }
-  /**
-   * Apply rollback
-   */
   applyRollback(action) {
-    if (!this.feedManager) return;
-    this.feedManager.updateVideo(action.videoId, action.rollbackData);
+    this.feedManager?.updateItem(action.videoId, action.rollbackData);
+    this.emit({ type: "actionRollback", action });
   }
-  /**
-   * Add pending action to store
-   */
   addPendingAction(action) {
-    const state = this.store.getState();
-    const newPendingActions = new Map(state.pendingActions);
-    newPendingActions.set(action.id, action);
-    this.store.setState({
-      pendingActions: newPendingActions,
-      hasPending: true
+    this.store.setState((state) => {
+      const m = new Map(state.pendingActions);
+      m.set(action.id, action);
+      return { pendingActions: m, hasPending: true };
     });
   }
-  /**
-   * Mark action as success
-   */
-  markActionSuccess(actionId) {
-    const state = this.store.getState();
-    const newPendingActions = new Map(state.pendingActions);
-    newPendingActions.delete(actionId);
-    const newFailedQueue = state.failedQueue.filter((id) => id !== actionId);
-    this.store.setState({
-      pendingActions: newPendingActions,
-      failedQueue: newFailedQueue,
-      hasPending: newPendingActions.size > 0
+  markActionSuccess(id) {
+    this.store.setState((state) => {
+      const m = new Map(state.pendingActions);
+      const action = m.get(id);
+      if (action) {
+        this.emit({ type: "actionSuccess", action: { ...action, status: "success" } });
+      }
+      m.delete(id);
+      const q = state.failedQueue.filter((x) => x !== id);
+      return { pendingActions: m, failedQueue: q, hasPending: m.size > 0 };
     });
   }
-  /**
-   * Mark action as failed
-   */
-  markActionFailed(actionId, error) {
-    const state = this.store.getState();
-    const action = state.pendingActions.get(actionId);
-    if (!action) return;
-    const newPendingActions = new Map(state.pendingActions);
-    newPendingActions.set(actionId, {
-      ...action,
-      status: "failed",
-      error
-    });
-    const newFailedQueue = state.failedQueue.includes(actionId) ? state.failedQueue : [...state.failedQueue, actionId];
-    this.store.setState({
-      pendingActions: newPendingActions,
-      failedQueue: newFailedQueue
+  markActionFailed(id, error) {
+    this.store.setState((state) => {
+      const m = new Map(state.pendingActions);
+      const a = m.get(id);
+      if (!a) return state;
+      const failedAction = { ...a, status: "failed", error };
+      m.set(id, failedAction);
+      const q = state.failedQueue.includes(id) ? state.failedQueue : [...state.failedQueue, id];
+      this.emit({
+        type: "actionFailed",
+        action: failedAction,
+        error: new Error(error)
+      });
+      return { pendingActions: m, failedQueue: q };
     });
   }
-  /**
-   * Retry a failed action
-   */
   async retryAction(action) {
-    this.emitEvent({ type: "retryStart", actionId: action.id });
-    const state = this.store.getState();
-    const newPendingActions = new Map(state.pendingActions);
-    const updatedAction = {
-      ...action,
-      retryCount: action.retryCount + 1,
-      status: "pending",
-      error: void 0
-    };
-    newPendingActions.set(action.id, updatedAction);
-    const newFailedQueue = state.failedQueue.filter((id) => id !== action.id);
-    this.store.setState({
-      pendingActions: newPendingActions,
-      failedQueue: newFailedQueue
+    this.store.setState((state) => {
+      const m = new Map(state.pendingActions);
+      const a = m.get(action.id);
+      if (a) {
+        m.set(action.id, { ...a, retryCount: a.retryCount + 1 });
+      }
+      return { pendingActions: m };
     });
-    const video = this.feedManager?.getVideo(action.videoId);
-    if (video) {
-      this.applyOptimisticUpdate(action.type, video);
-    }
+    const updatedAction = this.store.getState().pendingActions.get(action.id);
+    if (!updatedAction) return;
+    this.emit({ type: "retryStart", actionId: updatedAction.id });
     try {
-      await this.executeApiCall(action.type, action.videoId);
-      this.markActionSuccess(action.id);
-      this.emitEvent({ type: "actionSuccess", action: { ...updatedAction, status: "success" } });
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      if (updatedAction.retryCount >= this.config.maxRetries) {
-        this.emitEvent({ type: "retryExhausted", action: updatedAction });
-        this.markActionFailed(action.id, "Max retries exhausted");
-      } else {
-        this.markActionFailed(action.id, err.message);
+      if (updatedAction.type === "like") await this.interaction?.like(updatedAction.videoId);
+      else if (updatedAction.type === "unlike")
+        await this.interaction?.unlike(updatedAction.videoId);
+      else if (updatedAction.type === "follow")
+        await this.interaction?.follow(updatedAction.videoId);
+      else if (updatedAction.type === "unfollow")
+        await this.interaction?.unfollow(updatedAction.videoId);
+      const currentItem = this.feedManager?.getItem(updatedAction.videoId);
+      if (currentItem) {
+        this.applyOptimisticUpdate(updatedAction.type, currentItem);
       }
-      this.applyRollback(action);
-    }
-  }
-  /**
-   * Execute API call based on action type
-   */
-  async executeApiCall(type, videoId) {
-    if (!this.interaction) throw new Error("No interaction adapter");
-    switch (type) {
-      case "like":
-        await this.interaction.like(videoId);
-        break;
-      case "unlike":
-        await this.interaction.unlike(videoId);
-        break;
-      case "follow":
-        await this.interaction.follow(videoId);
-        break;
-      case "unfollow":
-        await this.interaction.unfollow(videoId);
-        break;
+      this.markActionSuccess(updatedAction.id);
+    } catch (e) {
+      this.markActionFailed(updatedAction.id, String(e));
+      this.applyRollback(updatedAction);
     }
   }
-  /**
-   * Schedule retry of failed actions
-   */
   scheduleRetry() {
     if (this.retryTimer) return;
     this.retryTimer = setTimeout(() => {
@@ -2922,30 +3039,6 @@ var OptimisticManager = class {
       this.retryFailed();
     }, this.config.retryDelayMs);
   }
-  /**
-   * Cancel retry timer
-   */
-  cancelRetryTimer() {
-    if (this.retryTimer) {
-      clearTimeout(this.retryTimer);
-      this.retryTimer = null;
-    }
-  }
-  /**
-   * Emit event to all listeners
-   */
-  emitEvent(event) {
-    for (const listener of this.eventListeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        this.logger?.error(
-          "[OptimisticManager] Event listener error",
-          err instanceof Error ? err : new Error(String(err))
-        );
-      }
-    }
-  }
 };
 
 // src/comment/types.ts
@@ -3369,8 +3462,8 @@ var CommentManager = class {
   // PRIVATE - OPTIMISTIC UPDATE HELPERS
   // ═══════════════════════════════════════════════════════════════
   addOptimisticComment(videoId, comment) {
-    const videoState = this.store.getState().byVideoId.get(videoId);
-    if (!videoState) return;
+    const state = this.store.getState();
+    const videoState = state.byVideoId.get(videoId) ?? createInitialVideoCommentState();
     const commentsById = new Map(videoState.commentsById);
     commentsById.set(comment.id, comment);
     const displayOrder = [comment.id, ...videoState.displayOrder];
@@ -3393,14 +3486,19 @@ var CommentManager = class {
     });
   }
   replaceOptimisticComment(videoId, optimisticId, realComment) {
-    const videoState = this.store.getState().byVideoId.get(videoId);
-    if (!videoState) return;
+    const state = this.store.getState();
+    const videoState = state.byVideoId.get(videoId) ?? createInitialVideoCommentState();
     const commentsById = new Map(videoState.commentsById);
     commentsById.delete(optimisticId);
     commentsById.set(realComment.id, realComment);
-    const displayOrder = videoState.displayOrder.map(
-      (id) => id === optimisticId ? realComment.id : id
-    );
+    let displayOrder;
+    if (videoState.displayOrder.includes(optimisticId)) {
+      displayOrder = videoState.displayOrder.map(
+        (id) => id === optimisticId ? realComment.id : id
+      );
+    } else {
+      displayOrder = [realComment.id, ...videoState.displayOrder];
+    }
     this.updateVideoState(videoId, { commentsById, displayOrder });
   }
   addOptimisticReply(videoId, parentId, reply) {
@@ -3566,4 +3664,303 @@ var CommentManager = class {
   }
 };
 
-export { CommentManager, DEFAULT_COMMENT_MANAGER_CONFIG, DEFAULT_FEED_CONFIG, DEFAULT_LIFECYCLE_CONFIG, DEFAULT_OPTIMISTIC_CONFIG, DEFAULT_PLAYER_CONFIG, DEFAULT_PREFETCH_CACHE_CONFIG, DEFAULT_PREFETCH_CONFIG, DEFAULT_RESOURCE_CONFIG, FeedManager, LifecycleManager, OptimisticManager, PlayerEngine, PlayerStatus, ResourceGovernor, calculatePrefetchIndices, calculateWindowIndices, canPause, canPlay, canSeek, computeAllocationChanges, createInitialCommentState, createInitialVideoCommentState, isActiveState, isValidTransition, mapNetworkType };
+// src/playlist/types.ts
+var DEFAULT_PLAYLIST_CONFIG = {
+  metadataWindowSize: 10
+};
+
+// src/playlist/PlaylistManager.ts
+var createInitialState6 = () => ({
+  playlist: null,
+  currentIndex: 0,
+  items: [],
+  loading: false,
+  error: null
+});
+var PlaylistManager = class {
+  constructor(dataSource, config = {}, governor, storage) {
+    this.dataSource = dataSource;
+    this.governor = governor;
+    this.storage = storage;
+    /**
+     * Internal cache of full metadata items.
+     * Items in store.items may be minified to save memory.
+     */
+    this.fullMetadataItems = [];
+    this.config = { ...DEFAULT_PLAYLIST_CONFIG, ...config };
+    this.store = createStore(createInitialState6);
+    if (this.governor) {
+      this.governorUnsubscribe = this.governor.addEventListener((event) => {
+        if (event.type === "focusChange") {
+          this.jumpTo(event.index);
+        }
+      });
+    }
+    this.store.subscribe((state, prevState) => {
+      if (state.currentIndex !== prevState.currentIndex || state.playlist !== prevState.playlist) {
+        this.updateMetadataWindow(state.currentIndex);
+      }
+    });
+  }
+  /**
+   * Load a playlist by ID
+   */
+  /**
+   * Generates a cache key for a specific playlist
+   */
+  getCacheKey(id) {
+    return `sv-playlist-data-${id}`;
+  }
+  /**
+   * Load playlist data, using cache for an immediate render before network finishes.
+   */
+  async loadPlaylist(id) {
+    if (!this.dataSource) {
+      this.store.setState({ error: new Error("No playlist data source provided") });
+      return;
+    }
+    const cacheKey = this.getCacheKey(id);
+    try {
+      if (this.storage) {
+        const cachedPlaylist = await this.storage.get(cacheKey);
+        if (cachedPlaylist) {
+          this.setPlaylist(cachedPlaylist);
+        }
+      }
+    } catch {
+    }
+    this.store.setState({ loading: true, error: null });
+    try {
+      const playlist = await this.dataSource.fetchPlaylist(id);
+      this.setPlaylist(playlist);
+      if (this.storage) {
+        const itemsToCache = playlist.items.slice(0, Math.max(this.config.metadataWindowSize, 5));
+        const cachePayload = { ...playlist, items: itemsToCache };
+        this.storage.set(cacheKey, cachePayload).catch(() => {
+        });
+      }
+    } catch (error) {
+      if (!this.store.getState().playlist) {
+        this.store.setState({
+          loading: false,
+          error: error instanceof Error ? error : new Error("Failed to load playlist")
+        });
+      } else {
+        this.store.setState({ loading: false });
+      }
+    }
+  }
+  /**
+   * Set playlist data directly
+   */
+  setPlaylist(playlist) {
+    this.fullMetadataItems = [...playlist.items];
+    const { metadataWindowSize } = this.config;
+    const end = Math.min(this.fullMetadataItems.length, metadataWindowSize);
+    const windowedItems = this.fullMetadataItems.map(
+      (item, index) => index < end ? item : this.minifyItem(item)
+    );
+    this.store.setState({
+      playlist,
+      currentIndex: 0,
+      items: windowedItems,
+      loading: false,
+      error: null
+    });
+  }
+  /**
+   * Navigate to next item
+   */
+  next() {
+    const { currentIndex, items } = this.store.getState();
+    if (currentIndex < items.length - 1) {
+      this.store.setState({ currentIndex: currentIndex + 1 });
+    }
+  }
+  /**
+   * Navigate to previous item
+   */
+  prev() {
+    const { currentIndex } = this.store.getState();
+    if (currentIndex > 0) {
+      this.store.setState({ currentIndex: currentIndex - 1 });
+    }
+  }
+  /**
+   * Jump to specific index
+   */
+  jumpTo(index) {
+    const { items } = this.store.getState();
+    if (index >= 0 && index < items.length) {
+      this.store.setState({ currentIndex: index });
+    }
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.fullMetadataItems = [];
+    this.store.setState(createInitialState6());
+  }
+  /**
+   * Get the full (un-minified) list of items in the current playlist.
+   *
+   * Unlike `store.items` (which applies the sliding window and may contain
+   * minified items), this always returns the complete metadata for every item.
+   * Used by PlaylistFeedAdapter to ensure FeedManager receives playable data.
+   */
+  getFullItems() {
+    return [...this.fullMetadataItems];
+  }
+  /**
+   * Destroy the manager
+   */
+  destroy() {
+    this.governorUnsubscribe?.();
+    this.reset();
+  }
+  /**
+   * Update the sliding window of full metadata items.
+   * Items outside the window are minified to save memory.
+   */
+  updateMetadataWindow(currentIndex) {
+    const { metadataWindowSize } = this.config;
+    const items = this.fullMetadataItems;
+    if (items.length === 0) return;
+    const halfWindow = Math.floor(metadataWindowSize / 2);
+    let start = Math.max(0, currentIndex - halfWindow);
+    const end = Math.min(items.length, start + metadataWindowSize);
+    if (end === items.length) {
+      start = Math.max(0, end - metadataWindowSize);
+    }
+    const windowedItems = items.map((item, index) => {
+      if (index >= start && index < end) {
+        return item;
+      }
+      return this.minifyItem(item);
+    });
+    this.store.setState({ items: windowedItems });
+  }
+  /**
+   * Create a minified version of a ContentItem to save memory.
+   * Keeps only essential fields for identification and basic UI.
+   */
+  minifyItem(item) {
+    return {
+      id: item.id,
+      type: item.type,
+      author: {
+        id: item.author.id,
+        name: item.author.name
+      },
+      // Essential stats for basic UI if needed
+      stats: {
+        likes: 0,
+        comments: 0,
+        shares: 0
+      },
+      isLiked: false,
+      isFollowing: false,
+      createdAt: ""
+    };
+  }
+};
+
+// src/playlist/PlaylistCollectionManager.ts
+var createInitialState7 = () => ({
+  playlists: [],
+  loading: false,
+  cursor: null,
+  hasMore: true,
+  error: null
+});
+var _PlaylistCollectionManager = class _PlaylistCollectionManager {
+  constructor(dataSource, storage) {
+    this.dataSource = dataSource;
+    this.storage = storage;
+    this.store = createStore(createInitialState7);
+  }
+  /**
+   * Hydrate collection from cache
+   */
+  async hydrateFromCache() {
+    if (!this.storage) return;
+    try {
+      const cached = await this.storage.get(_PlaylistCollectionManager.CACHE_KEY);
+      if (Array.isArray(cached?.playlists)) {
+        this.store.setState({
+          playlists: cached.playlists,
+          cursor: cached.cursor,
+          hasMore: cached.hasMore
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Update cache with current state
+   */
+  updateCache() {
+    if (!this.storage) return;
+    const { playlists, cursor, hasMore } = this.store.getState();
+    this.storage.set(_PlaylistCollectionManager.CACHE_KEY, { playlists, cursor, hasMore }).catch(() => {
+    });
+  }
+  /**
+   * Load more playlists (pagination)
+   */
+  async loadMore() {
+    const { loading, cursor, hasMore } = this.store.getState();
+    if (loading || !hasMore || !this.dataSource) return;
+    this.store.setState({ loading: true, error: null });
+    try {
+      const response = await this.dataSource.fetchPlaylistCollection(cursor || void 0);
+      this.store.setState((state) => ({
+        playlists: [...state.playlists, ...response.playlists],
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loading: false
+      }));
+      this.updateCache();
+    } catch (error) {
+      this.store.setState({
+        loading: false,
+        error: error instanceof Error ? error : new Error("Failed to load playlist collection")
+      });
+    }
+  }
+  /**
+   * Refresh the collection (reset and re-fetch)
+   */
+  async refresh() {
+    if (!this.dataSource) return;
+    this.store.setState({ ...createInitialState7(), loading: true });
+    try {
+      const response = await this.dataSource.fetchPlaylistCollection();
+      this.store.setState({
+        playlists: response.playlists,
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loading: false,
+        error: null
+      });
+      this.updateCache();
+    } catch (error) {
+      this.store.setState({
+        loading: false,
+        error: error instanceof Error ? error : new Error("Failed to refresh playlist collection")
+      });
+    }
+  }
+  /**
+   * Reset the store to initial state
+   */
+  reset() {
+    this.store.setState(createInitialState7());
+  }
+};
+/** Cache key for playlist collection */
+_PlaylistCollectionManager.CACHE_KEY = "sv-playlist-collection";
+var PlaylistCollectionManager = _PlaylistCollectionManager;
+
+export { CommentManager, DEFAULT_COMMENT_MANAGER_CONFIG, DEFAULT_FEED_CONFIG, DEFAULT_LIFECYCLE_CONFIG, DEFAULT_OPTIMISTIC_CONFIG, DEFAULT_PLAYER_CONFIG, DEFAULT_PREFETCH_CACHE_CONFIG, DEFAULT_PREFETCH_CONFIG, DEFAULT_RESOURCE_CONFIG, FeedManager, LifecycleManager, OptimisticManager, PlayerEngine, PlayerStatus, PlaylistCollectionManager, PlaylistManager, ResourceGovernor, calculatePrefetchIndices, calculateWindowIndices, canPause, canPlay, canSeek, computeAllocationChanges, createInitialCommentState, createInitialVideoCommentState, isActiveState, isValidTransition, mapNetworkType };