@xhub-short/core 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/index.js

@@ -1,6 +1,26 @@
-import { createStore } from 'zustand/vanilla';
-
-// src/feed/FeedManager.ts
+// ../../node_modules/.pnpm/zustand@5.0.9_@types+react@19.2.7_react@19.2.3/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
 
 // src/feed/types.ts
 var DEFAULT_FEED_CONFIG = {
@@ -13,6 +33,13 @@ var DEFAULT_FEED_CONFIG = {
   maxCacheSize: 100,
   enableGC: true
 };
+var DEFAULT_PREFETCH_CACHE_CONFIG = {
+  enabled: true,
+  maxVideos: 10,
+  storageKey: "sv-prefetch-cache",
+  enableDynamicEviction: true,
+  evictionThrottleMs: 2e3
+};
 
 // src/feed/FeedManager.ts
 var createInitialState = () => ({
@@ -26,8 +53,8 @@ var createInitialState = () => ({
   isStale: false,
   lastFetchTime: null
 });
-var FeedManager = class {
-  constructor(dataSource, config = {}) {
+var _FeedManager = class _FeedManager {
+  constructor(dataSource, config = {}, storage, prefetchConfig) {
     this.dataSource = dataSource;
     /** Abort controller for cancelling in-flight requests */
     this.abortController = null;
@@ -42,8 +69,46 @@ var FeedManager = class {
      */
     this.accessOrder = /* @__PURE__ */ new Map();
     this.config = { ...DEFAULT_FEED_CONFIG, ...config };
+    this.prefetchConfig = { ...DEFAULT_PREFETCH_CACHE_CONFIG, ...prefetchConfig };
+    this.storage = storage ?? null;
     this.store = createStore(createInitialState);
   }
+  /**
+   * Prefetch feed data and store in global memory cache
+   *
+   * @param dataSource - Data source to fetch from
+   * @param options - Prefetch options
+   */
+  static async prefetch(dataSource, options = {}) {
+    if (_FeedManager.globalMemoryCache) {
+      const now = Date.now();
+      const ttl = options.ttl ?? 5 * 60 * 1e3;
+      if (now - _FeedManager.globalMemoryCache.timestamp < ttl) {
+        return;
+      }
+    }
+    try {
+      const response = await dataSource.fetchFeed(void 0);
+      _FeedManager.globalMemoryCache = {
+        items: response.items,
+        nextCursor: response.nextCursor,
+        timestamp: Date.now()
+      };
+    } catch {
+    }
+  }
+  /**
+   * Check if prefetch cache exists and is valid
+   */
+  static hasPrefetchCache() {
+    return !!_FeedManager.globalMemoryCache;
+  }
+  /**
+   * Clear prefetch cache
+   */
+  static clearPrefetchCache() {
+    _FeedManager.globalMemoryCache = null;
+  }
   // ═══════════════════════════════════════════════════════════════
   // PUBLIC API
   // ═══════════════════════════════════════════════════════════════
@@ -60,6 +125,12 @@ var FeedManager = class {
    * - Prevents duplicate API calls from rapid UI interactions
    */
   async loadInitial() {
+    if (_FeedManager.globalMemoryCache) {
+      const { items, nextCursor } = _FeedManager.globalMemoryCache;
+      this.hydrateFromSnapshot(items, nextCursor, { markAsStale: false });
+      _FeedManager.globalMemoryCache = null;
+      return;
+    }
     const dedupeKey = "__initial__";
     const existingRequest = this.inFlightRequests.get(dedupeKey);
     if (existingRequest) {
@@ -84,6 +155,7 @@ var FeedManager = class {
   async executeLoadInitial() {
     try {
       await this.fetchWithRetry();
+      this.updatePrefetchCache();
     } catch (error) {
       this.handleError(error, "loadInitial");
     } finally {
@@ -124,6 +196,7 @@ var FeedManager = class {
   async executeLoadMore(cursor) {
     try {
       await this.fetchWithRetry(cursor);
+      this.updatePrefetchCache();
     } catch (error) {
       this.handleError(error, "loadMore");
     } finally {
@@ -182,6 +255,40 @@ var FeedManager = class {
       this.store.setState({ itemsById: newItemsById });
     }
   }
+  /**
+   * 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 video
+   * const wasRemoved = feedManager.removeItem(videoId);
+   * if (wasRemoved) {
+   *   // Navigate to next video
+   * }
+   * ```
+   */
+  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
    */
@@ -252,6 +359,121 @@ var FeedManager = class {
     });
   }
   // ═══════════════════════════════════════════════════════════════
+  // 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
+   */
+  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) {
+      return;
+    }
+    const tailVideos = allVideos.slice(-this.prefetchConfig.maxVideos);
+    const cacheData = {
+      items: tailVideos,
+      savedAt: Date.now(),
+      cursor: state.cursor
+    };
+    this.savePrefetchCacheAsync(cacheData);
+  }
+  /**
+   * Save prefetch cache to storage (async, non-blocking)
+   */
+  async savePrefetchCacheAsync(data) {
+    if (!this.storage) return;
+    try {
+      await this.storage.set(this.prefetchConfig.storageKey, data);
+    } catch {
+    }
+  }
+  /**
+   * Load prefetch cache from storage
+   * Returns null if no cache, disabled, or storage error
+   */
+  async loadPrefetchCache() {
+    if (!this.prefetchConfig.enabled) return null;
+    if (!this.storage) return null;
+    try {
+      const data = await this.storage.get(this.prefetchConfig.storageKey);
+      if (!data || !data.items || data.items.length === 0) {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Hydrate feed from prefetch cache for instant display
+   * Marks data as stale to trigger background revalidation
+   */
+  hydrateFromPrefetchCache(cache) {
+    this.hydrateFromSnapshot(cache.items, cache.cursor, {
+      markAsStale: true
+      // Trigger revalidation
+    });
+  }
+  /**
+   * Clear prefetch cache
+   * Call when user logs out or data should be invalidated
+   */
+  async clearPrefetchCache() {
+    if (!this.storage) return;
+    try {
+      await this.storage.remove(this.prefetchConfig.storageKey);
+    } catch {
+    }
+  }
+  /**
+   * Evict videos 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
+   *
+   * @param currentIndex - Current focused video index in feed
+   */
+  async evictViewedVideosFromCache(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));
+      if (updatedItems.length === cache.items.length) return;
+      if (updatedItems.length === 0) {
+        await this.storage.remove(this.prefetchConfig.storageKey);
+        return;
+      }
+      const updatedCache = {
+        ...cache,
+        items: updatedItems,
+        savedAt: Date.now()
+      };
+      await this.storage.set(this.prefetchConfig.storageKey, updatedCache);
+    } catch {
+    }
+  }
+  /**
+   * Get prefetch cache configuration (for external access)
+   */
+  getPrefetchConfig() {
+    return this.prefetchConfig;
+  }
+  // ═══════════════════════════════════════════════════════════════
   // PRIVATE METHODS
   // ═══════════════════════════════════════════════════════════════
   /**
@@ -459,6 +681,12 @@ var FeedManager = class {
     };
   }
 };
+// ═══════════════════════════════════════════════════════════════
+// STATIC MEMORY CACHE (PREFETCH)
+// ═══════════════════════════════════════════════════════════════
+/** Static memory cache for explicit prefetching */
+_FeedManager.globalMemoryCache = null;
+var FeedManager = _FeedManager;
 
 // src/player/types.ts
 var PlayerStatus = /* @__PURE__ */ ((PlayerStatus2) => {
@@ -546,7 +774,8 @@ var createInitialState2 = (config) => ({
   ended: false,
   // Session restore
   pendingRestoreTime: null,
-  pendingRestoreVideoId: null
+  pendingRestoreVideoId: null,
+  pendingRestoreFrame: null
 });
 var PlayerEngine = class {
   constructor(config = {}) {
@@ -595,7 +824,11 @@ var PlayerEngine = class {
       }
       return false;
     }
-    const currentStatus = this.store.getState().status;
+    const currentState = this.store.getState();
+    const currentStatus = currentState.status;
+    if (currentState.currentVideo && currentState.currentVideo.id !== video.id) {
+      this.trackLeaveVideo(currentState);
+    }
     if (currentStatus !== "idle" /* IDLE */ && currentStatus !== "error" /* ERROR */ && currentStatus !== "paused" /* PAUSED */) {
       if (!this.transitionTo("idle" /* IDLE */)) {
         return false;
@@ -612,7 +845,9 @@ var PlayerEngine = class {
       loopCount: 0,
       watchTime: 0,
       error: null,
-      ended: false
+      ended: false,
+      playbackRate: 1
+      // Reset speed to normal when loading new video
     });
     this.emitEvent({ type: "videoChange", video });
     this.logger?.debug(`[PlayerEngine] Loaded video: ${video.id}`);
@@ -821,22 +1056,24 @@ var PlayerEngine = class {
    * ```typescript
    * // During session restore
    * if (result.playbackTime && result.currentVideoId) {
-   *   playerEngine.setRestorePosition(result.currentVideoId, result.playbackTime);
+   *   playerEngine.setRestorePosition(result.currentVideoId, result.playbackTime, result.restoreFrame);
    * }
    * ```
    */
-  setRestorePosition(videoId, time) {
+  setRestorePosition(videoId, time, frame) {
     this.store.setState({
       pendingRestoreTime: time,
-      pendingRestoreVideoId: videoId
+      pendingRestoreVideoId: videoId,
+      pendingRestoreFrame: frame ?? null
     });
-    this.logger?.debug("[PlayerEngine] Set restore position", { videoId, time });
+    this.logger?.debug("[PlayerEngine] Set restore position", { videoId, time, hasFrame: !!frame });
   }
   /**
    * Get and clear restore position for a video.
    *
    * VideoPlayer calls this when rendering to get startTime.
    * Position is cleared after being read to prevent reuse.
+   * Note: restoreFrame is NOT cleared here - use consumeRestoreFrame() separately.
    *
    * @param videoId - Video ID to check
    * @returns Restore time in seconds, or null if no pending restore
@@ -846,14 +1083,51 @@ var PlayerEngine = class {
     if (state.pendingRestoreVideoId === videoId && state.pendingRestoreTime !== null) {
       const time = state.pendingRestoreTime;
       this.store.setState({
-        pendingRestoreTime: null,
-        pendingRestoreVideoId: null
+        pendingRestoreTime: null
+        // Note: pendingRestoreVideoId and pendingRestoreFrame kept for frame consumption
       });
       this.logger?.debug("[PlayerEngine] Consumed restore position", { videoId, time });
       return time;
     }
     return null;
   }
+  /**
+   * Get and clear restore frame for a video.
+   *
+   * VideoSlot calls this to display instant preview while video loads.
+   * Frame is cleared after being read to free memory.
+   *
+   * @param videoId - Video ID to check
+   * @returns Base64 JPEG data URL, or null if no pending frame
+   */
+  consumeRestoreFrame(videoId) {
+    const state = this.store.getState();
+    if (state.pendingRestoreVideoId === videoId && state.pendingRestoreFrame !== null) {
+      const frame = state.pendingRestoreFrame;
+      this.store.setState({
+        pendingRestoreFrame: null,
+        pendingRestoreVideoId: null
+        // Clear video ID since we've consumed both time and frame
+      });
+      this.logger?.debug("[PlayerEngine] Consumed restore frame", { videoId });
+      return frame;
+    }
+    return null;
+  }
+  /**
+   * Get restore frame without consuming (peek).
+   * Used to display preview while keeping it available.
+   *
+   * @param videoId - Video ID to check
+   * @returns Base64 JPEG data URL, or null if no pending frame
+   */
+  peekRestoreFrame(videoId) {
+    const state = this.store.getState();
+    if (state.pendingRestoreVideoId === videoId && state.pendingRestoreFrame !== null) {
+      return state.pendingRestoreFrame;
+    }
+    return null;
+  }
   /**
    * Check if there's a pending restore position for a video.
    *
@@ -964,13 +1238,23 @@ var PlayerEngine = class {
   }
   /**
    * Start watch time tracking
+   * Increments watchTime every second and sends analytics heartbeat
    */
   startWatchTimeTracking() {
     if (this.watchTimeInterval) return;
     this.watchTimeInterval = setInterval(() => {
       const state = this.store.getState();
-      if (state.status === "playing" /* PLAYING */) {
-        this.store.setState({ watchTime: state.watchTime + 1 });
+      if (state.status === "playing" /* PLAYING */ && state.currentVideo) {
+        const newWatchTime = state.watchTime + 1;
+        this.store.setState({ watchTime: newWatchTime });
+        if (this.analytics && newWatchTime >= this.config.watchTimeThreshold) {
+          this.analytics.trackViewDuration(
+            state.currentVideo.id,
+            state.currentTime,
+            // Use playback position (currentTime) for API
+            state.duration
+          );
+        }
       }
     }, 1e3);
   }
@@ -984,7 +1268,7 @@ var PlayerEngine = class {
     }
   }
   /**
-   * Track completion analytics
+   * Track completion analytics (when video loops/ends)
    */
   trackCompletion(state, loopCount) {
     if (!this.analytics || !state.currentVideo) return;
@@ -996,6 +1280,27 @@ var PlayerEngine = class {
       this.analytics.trackCompletion(state.currentVideo.id, state.watchTime, loopCount);
     }
   }
+  /**
+   * Track when user leaves current video (scrolls to next video)
+   * Sends final analytics event before video change
+   */
+  trackLeaveVideo(state) {
+    if (!this.analytics || !state.currentVideo) return;
+    if (state.watchTime >= this.config.watchTimeThreshold) {
+      this.analytics.trackViewDuration(
+        state.currentVideo.id,
+        state.currentTime,
+        // Use currentTime (playback position) instead of watchTime
+        state.duration
+      );
+      this.logger?.debug("[PlayerEngine] Tracked leave event", {
+        videoId: state.currentVideo.id,
+        watchTime: state.watchTime,
+        currentTime: state.currentTime
+      });
+    }
+    this.stopWatchTimeTracking();
+  }
   /**
    * Categorize media error
    */
@@ -1331,6 +1636,9 @@ var LifecycleManager = class {
         if (validSnapshot.currentVideoId !== void 0) {
           result.currentVideoId = validSnapshot.currentVideoId;
         }
+        if (validSnapshot.restoreFrame !== void 0) {
+          result.restoreFrame = validSnapshot.restoreFrame;
+        }
       }
       this.store.setState({
         isRestoring: false,
@@ -1341,7 +1649,8 @@ var LifecycleManager = class {
       this.logger?.debug("[LifecycleManager] Session restored", {
         itemCount: validSnapshot.items.length,
         needsRevalidation,
-        hasPlaybackTime: this.config.restorePlaybackPosition && validSnapshot.playbackTime !== void 0
+        hasPlaybackTime: this.config.restorePlaybackPosition && validSnapshot.playbackTime !== void 0,
+        hasRestoreFrame: this.config.restorePlaybackPosition && validSnapshot.restoreFrame !== void 0
       });
       return result;
     } catch (error) {
@@ -1366,6 +1675,7 @@ var LifecycleManager = class {
    * @param data - Snapshot data to save
    * @param data.playbackTime - Current video playback position (only saved if restorePlaybackPosition config is enabled)
    * @param data.currentVideoId - Current video ID (only saved if restorePlaybackPosition config is enabled)
+   * @param data.restoreFrame - Captured video frame at playback position (only saved if restorePlaybackPosition is enabled)
    */
   async saveSnapshot(data) {
     if (!this.storage) {
@@ -1394,6 +1704,9 @@ var LifecycleManager = class {
         if (data.currentVideoId !== void 0) {
           snapshot.currentVideoId = data.currentVideoId;
         }
+        if (data.restoreFrame !== void 0) {
+          snapshot.restoreFrame = data.restoreFrame;
+        }
       }
       await this.storage.saveSnapshot(snapshot);
       const timestamp = Date.now();
@@ -1404,7 +1717,8 @@ var LifecycleManager = class {
       this.emitEvent({ type: "saveComplete", timestamp });
       this.logger?.debug("[LifecycleManager] Snapshot saved", {
         itemCount: data.items.length,
-        hasPlaybackTime: this.config.restorePlaybackPosition && data.playbackTime !== void 0
+        hasPlaybackTime: this.config.restorePlaybackPosition && data.playbackTime !== void 0,
+        hasRestoreFrame: this.config.restorePlaybackPosition && data.restoreFrame !== void 0
       });
       return true;
     } catch (error) {
@@ -2670,4 +2984,627 @@ var OptimisticManager = class {
   }
 };
 
-export { DEFAULT_FEED_CONFIG, DEFAULT_LIFECYCLE_CONFIG, DEFAULT_OPTIMISTIC_CONFIG, DEFAULT_PLAYER_CONFIG, DEFAULT_PREFETCH_CONFIG, DEFAULT_RESOURCE_CONFIG, FeedManager, LifecycleManager, OptimisticManager, PlayerEngine, PlayerStatus, ResourceGovernor, calculatePrefetchIndices, calculateWindowIndices, canPause, canPlay, canSeek, computeAllocationChanges, isActiveState, isValidTransition, mapNetworkType };
+// src/comment/types.ts
+var DEFAULT_COMMENT_MANAGER_CONFIG = {
+  pageSize: 20,
+  repliesPageSize: 10,
+  cacheTTL: 5 * 60 * 1e3,
+  // 5 minutes
+  maxRetries: 2,
+  repliesAutoExpandThreshold: 1,
+  repliesCollapseLimit: 3,
+  textMaxLines: 3,
+  enableOptimistic: true
+};
+var createInitialVideoCommentState = () => ({
+  commentsById: /* @__PURE__ */ new Map(),
+  displayOrder: [],
+  totalCount: 0,
+  cursor: null,
+  hasMore: true,
+  loading: false,
+  loadingMore: false,
+  error: null,
+  cachedAt: 0,
+  isStale: true
+});
+var createInitialCommentState = () => ({
+  byVideoId: /* @__PURE__ */ new Map(),
+  activeVideoId: null,
+  isPosting: false,
+  postError: null,
+  deletingId: null
+});
+
+// src/comment/CommentManager.ts
+var CommentManager = class {
+  constructor(adapter, config = {}, logger) {
+    this.adapter = adapter;
+    /** Request deduplication: Map of key → in-flight Promise */
+    this.inFlightRequests = /* @__PURE__ */ new Map();
+    /** Optimistic ID counter */
+    this.optimisticIdCounter = 0;
+    this.config = { ...DEFAULT_COMMENT_MANAGER_CONFIG, ...config };
+    this.store = createStore(createInitialCommentState);
+    this.logger = logger;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - READ OPERATIONS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Load comments for a video
+   *
+   * Features:
+   * - Cache check with TTL
+   * - Request deduplication
+   * - Stale data detection
+   */
+  async loadComments(videoId, forceRefresh = false) {
+    const dedupeKey = `loadComments:${videoId}`;
+    const existingRequest = this.inFlightRequests.get(dedupeKey);
+    if (existingRequest) {
+      this.logger?.debug(`[CommentManager] Deduped loadComments: ${videoId}`);
+      return existingRequest;
+    }
+    const state = this.store.getState();
+    const videoState = state.byVideoId.get(videoId);
+    if (!forceRefresh && videoState && !this.isCacheStale(videoState)) {
+      this.logger?.debug(`[CommentManager] Using cached comments: ${videoId}`);
+      return;
+    }
+    const request = this.executeLoadComments(videoId, forceRefresh);
+    this.inFlightRequests.set(dedupeKey, request);
+    try {
+      await request;
+    } finally {
+      this.inFlightRequests.delete(dedupeKey);
+    }
+  }
+  /**
+   * Load more comments (pagination)
+   */
+  async loadMore(videoId) {
+    const state = this.store.getState();
+    const videoState = state.byVideoId.get(videoId);
+    if (!videoState || videoState.loading || videoState.loadingMore || !videoState.hasMore) {
+      return;
+    }
+    const dedupeKey = `loadMore:${videoId}:${videoState.cursor}`;
+    const existingRequest = this.inFlightRequests.get(dedupeKey);
+    if (existingRequest) {
+      return existingRequest;
+    }
+    const request = this.executeLoadMore(videoId);
+    this.inFlightRequests.set(dedupeKey, request);
+    try {
+      await request;
+    } finally {
+      this.inFlightRequests.delete(dedupeKey);
+    }
+  }
+  /**
+   * Load replies for a comment
+   */
+  async loadReplies(commentId) {
+    const dedupeKey = `loadReplies:${commentId}`;
+    const existingRequest = this.inFlightRequests.get(dedupeKey);
+    if (existingRequest) {
+      return existingRequest;
+    }
+    const request = this.executeLoadReplies(commentId);
+    this.inFlightRequests.set(dedupeKey, request);
+    try {
+      await request;
+    } finally {
+      this.inFlightRequests.delete(dedupeKey);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - WRITE OPERATIONS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Post a new comment with optimistic UI
+   */
+  async postComment(videoId, content, currentUser) {
+    if (!content.trim()) return null;
+    const optimisticId = this.generateOptimisticId();
+    const optimisticComment = {
+      id: optimisticId,
+      videoId,
+      content: content.trim(),
+      author: currentUser,
+      likeCount: 0,
+      isLiked: false,
+      replyCount: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isOwner: true,
+      isPending: true
+    };
+    if (this.config.enableOptimistic) {
+      this.addOptimisticComment(videoId, optimisticComment);
+    }
+    this.store.setState({ isPosting: true, postError: null });
+    try {
+      const realComment = await this.adapter.postComment({ videoId, content: content.trim() });
+      this.replaceOptimisticComment(videoId, optimisticId, realComment);
+      this.logger?.debug(`[CommentManager] Posted comment: ${realComment.id}`);
+      return realComment;
+    } catch (error) {
+      if (this.config.enableOptimistic) {
+        this.removeOptimisticComment(videoId, optimisticId);
+      }
+      const commentError = this.createError(error);
+      this.store.setState({ postError: commentError });
+      this.logger?.warn("[CommentManager] Post failed", { error: commentError.message });
+      return null;
+    } finally {
+      this.store.setState({ isPosting: false });
+    }
+  }
+  /**
+   * Post a reply with optimistic UI
+   */
+  async postReply(videoId, parentId, content, currentUser, replyTo) {
+    if (!content.trim()) return null;
+    const optimisticId = this.generateOptimisticId();
+    const optimisticReply = {
+      id: optimisticId,
+      parentId,
+      content: content.trim(),
+      author: currentUser,
+      likeCount: 0,
+      isLiked: false,
+      replyTo,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isOwner: true,
+      isPending: true
+    };
+    if (this.config.enableOptimistic) {
+      this.addOptimisticReply(videoId, parentId, optimisticReply);
+    }
+    this.store.setState({ isPosting: true, postError: null });
+    try {
+      const realReply = await this.adapter.postReply({
+        videoId,
+        parentId,
+        content: content.trim(),
+        replyToUserId: replyTo?.id
+      });
+      this.replaceOptimisticReply(videoId, parentId, optimisticId, realReply);
+      this.logger?.debug(`[CommentManager] Posted reply: ${realReply.id}`);
+      return realReply;
+    } catch (error) {
+      if (this.config.enableOptimistic) {
+        this.removeOptimisticReply(videoId, parentId, optimisticId);
+      }
+      const commentError = this.createError(error);
+      this.store.setState({ postError: commentError });
+      this.logger?.warn("[CommentManager] Reply failed", { error: commentError.message });
+      return null;
+    } finally {
+      this.store.setState({ isPosting: false });
+    }
+  }
+  /**
+   * Delete a comment with optimistic UI
+   */
+  async deleteComment(videoId, commentId, isReply = false, parentId) {
+    const backup = isReply ? this.getReply(videoId, parentId, commentId) : this.getComment(videoId, commentId);
+    if (!backup) return false;
+    if (this.config.enableOptimistic) {
+      this.store.setState({ deletingId: commentId });
+      if (isReply && parentId) {
+        this.removeReplyFromStore(videoId, parentId, commentId);
+      } else {
+        this.removeCommentFromStore(videoId, commentId);
+      }
+    }
+    try {
+      await this.adapter.deleteComment({
+        videoId,
+        commentId,
+        isReply,
+        parentId
+      });
+      this.logger?.debug(`[CommentManager] Deleted ${isReply ? "reply" : "comment"}: ${commentId}`);
+      return true;
+    } catch (error) {
+      if (this.config.enableOptimistic) {
+        if (isReply && parentId) {
+          this.restoreReply(videoId, parentId, backup);
+        } else {
+          this.restoreComment(videoId, backup);
+        }
+      }
+      this.logger?.warn(`[CommentManager] Delete failed: ${commentId}`, {
+        error: error.message
+      });
+      return false;
+    } finally {
+      this.store.setState({ deletingId: null });
+    }
+  }
+  /**
+   * Like a comment/reply with optimistic UI
+   */
+  async likeComment(videoId, commentId, isReply = false, parentId) {
+    this.updateLikeState(videoId, commentId, true, isReply, parentId);
+    try {
+      await this.adapter.likeComment(commentId);
+    } catch (error) {
+      this.updateLikeState(videoId, commentId, false, isReply, parentId);
+      this.logger?.warn(`[CommentManager] Like failed: ${commentId}`, {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Unlike a comment/reply with optimistic UI
+   */
+  async unlikeComment(videoId, commentId, isReply = false, parentId) {
+    this.updateLikeState(videoId, commentId, false, isReply, parentId);
+    try {
+      await this.adapter.unlikeComment(commentId);
+    } catch (error) {
+      this.updateLikeState(videoId, commentId, true, isReply, parentId);
+      this.logger?.warn(`[CommentManager] Unlike failed: ${commentId}`, {
+        error: error.message
+      });
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - STATE ACCESSORS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get comments for a video
+   */
+  getComments(videoId) {
+    const state = this.store.getState();
+    const videoState = state.byVideoId.get(videoId);
+    if (!videoState) return [];
+    return videoState.displayOrder.map((id) => videoState.commentsById.get(id)).filter((c) => c !== void 0);
+  }
+  /**
+   * Get a single comment
+   */
+  getComment(videoId, commentId) {
+    const state = this.store.getState();
+    return state.byVideoId.get(videoId)?.commentsById.get(commentId);
+  }
+  /**
+   * Get a single reply
+   */
+  getReply(videoId, parentId, replyId) {
+    const comment = this.getComment(videoId, parentId);
+    return comment?.replies?.find((r) => r.id === replyId);
+  }
+  /**
+   * Get video comment state
+   */
+  getVideoState(videoId) {
+    return this.store.getState().byVideoId.get(videoId);
+  }
+  /**
+   * Set active video ID (for comment sheet)
+   */
+  setActiveVideo(videoId) {
+    this.store.setState({ activeVideoId: videoId });
+  }
+  /**
+   * Get config
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Clear comments for a video
+   */
+  clearVideoComments(videoId) {
+    const state = this.store.getState();
+    const newByVideoId = new Map(state.byVideoId);
+    newByVideoId.delete(videoId);
+    this.store.setState({ byVideoId: newByVideoId });
+  }
+  /**
+   * Clear all comments
+   */
+  clearAll() {
+    this.store.setState(createInitialCommentState());
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE - EXECUTE METHODS
+  // ═══════════════════════════════════════════════════════════════
+  async executeLoadComments(videoId, _forceRefresh) {
+    this.updateVideoState(videoId, { loading: true, error: null });
+    try {
+      const response = await this.adapter.getComments(videoId, null, this.config.pageSize);
+      const commentsById = /* @__PURE__ */ new Map();
+      const displayOrder = [];
+      for (const comment of response.items) {
+        commentsById.set(comment.id, comment);
+        displayOrder.push(comment.id);
+      }
+      this.updateVideoState(videoId, {
+        commentsById,
+        displayOrder,
+        totalCount: response.totalCount,
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loading: false,
+        cachedAt: Date.now(),
+        isStale: false
+      });
+      this.logger?.debug(
+        `[CommentManager] Loaded ${response.items.length} comments for ${videoId}`
+      );
+    } catch (error) {
+      const commentError = this.createError(error);
+      this.updateVideoState(videoId, { error: commentError, loading: false });
+      throw error;
+    }
+  }
+  async executeLoadMore(videoId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    this.updateVideoState(videoId, { loadingMore: true });
+    try {
+      const response = await this.adapter.getComments(
+        videoId,
+        videoState.cursor,
+        this.config.pageSize
+      );
+      const commentsById = new Map(videoState.commentsById);
+      const displayOrder = [...videoState.displayOrder];
+      for (const comment of response.items) {
+        if (!commentsById.has(comment.id)) {
+          commentsById.set(comment.id, comment);
+          displayOrder.push(comment.id);
+        }
+      }
+      this.updateVideoState(videoId, {
+        commentsById,
+        displayOrder,
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loadingMore: false
+      });
+      this.logger?.debug(`[CommentManager] Loaded ${response.items.length} more comments`);
+    } catch (error) {
+      this.updateVideoState(videoId, { loadingMore: false });
+      throw error;
+    }
+  }
+  async executeLoadReplies(commentId) {
+    try {
+      const response = await this.adapter.getReplies(commentId, null, this.config.repliesPageSize);
+      const state = this.store.getState();
+      for (const [videoId, videoState] of state.byVideoId) {
+        const comment = videoState.commentsById.get(commentId);
+        if (comment) {
+          const updatedComment = {
+            ...comment,
+            replies: response.items,
+            repliesCursor: response.nextCursor,
+            repliesLoaded: !response.hasMore
+          };
+          const commentsById = new Map(videoState.commentsById);
+          commentsById.set(commentId, updatedComment);
+          this.updateVideoState(videoId, { commentsById });
+          this.logger?.debug(
+            `[CommentManager] Loaded ${response.items.length} replies for ${commentId}`
+          );
+          break;
+        }
+      }
+    } catch (error) {
+      this.logger?.warn(`[CommentManager] Load replies failed: ${commentId}`);
+      throw error;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE - OPTIMISTIC UPDATE HELPERS
+  // ═══════════════════════════════════════════════════════════════
+  addOptimisticComment(videoId, comment) {
+    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];
+    this.updateVideoState(videoId, {
+      commentsById,
+      displayOrder,
+      totalCount: videoState.totalCount + 1
+    });
+  }
+  removeOptimisticComment(videoId, optimisticId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.delete(optimisticId);
+    const displayOrder = videoState.displayOrder.filter((id) => id !== optimisticId);
+    this.updateVideoState(videoId, {
+      commentsById,
+      displayOrder,
+      totalCount: Math.max(0, videoState.totalCount - 1)
+    });
+  }
+  replaceOptimisticComment(videoId, optimisticId, realComment) {
+    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);
+    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) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const comment = videoState.commentsById.get(parentId);
+    if (!comment) return;
+    const updatedComment = {
+      ...comment,
+      replies: [...comment.replies ?? [], reply],
+      replyCount: comment.replyCount + 1
+    };
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(parentId, updatedComment);
+    this.updateVideoState(videoId, { commentsById });
+  }
+  removeOptimisticReply(videoId, parentId, optimisticId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const comment = videoState.commentsById.get(parentId);
+    if (!comment) return;
+    const updatedComment = {
+      ...comment,
+      replies: comment.replies?.filter((r) => r.id !== optimisticId),
+      replyCount: Math.max(0, comment.replyCount - 1)
+    };
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(parentId, updatedComment);
+    this.updateVideoState(videoId, { commentsById });
+  }
+  replaceOptimisticReply(videoId, parentId, optimisticId, realReply) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const comment = videoState.commentsById.get(parentId);
+    if (!comment) return;
+    const updatedComment = {
+      ...comment,
+      replies: comment.replies?.map((r) => r.id === optimisticId ? realReply : r)
+    };
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(parentId, updatedComment);
+    this.updateVideoState(videoId, { commentsById });
+  }
+  removeCommentFromStore(videoId, commentId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.delete(commentId);
+    const displayOrder = videoState.displayOrder.filter((id) => id !== commentId);
+    this.updateVideoState(videoId, {
+      commentsById,
+      displayOrder,
+      totalCount: Math.max(0, videoState.totalCount - 1)
+    });
+  }
+  removeReplyFromStore(videoId, parentId, replyId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const comment = videoState.commentsById.get(parentId);
+    if (!comment) return;
+    const updatedComment = {
+      ...comment,
+      replies: comment.replies?.filter((r) => r.id !== replyId),
+      replyCount: Math.max(0, comment.replyCount - 1)
+    };
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(parentId, updatedComment);
+    this.updateVideoState(videoId, { commentsById });
+  }
+  restoreComment(videoId, comment) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(comment.id, comment);
+    const displayOrder = videoState.displayOrder.includes(comment.id) ? videoState.displayOrder : [comment.id, ...videoState.displayOrder];
+    this.updateVideoState(videoId, {
+      commentsById,
+      displayOrder,
+      totalCount: videoState.totalCount + 1
+    });
+  }
+  restoreReply(videoId, parentId, reply) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    const comment = videoState.commentsById.get(parentId);
+    if (!comment) return;
+    const updatedComment = {
+      ...comment,
+      replies: [...comment.replies ?? [], reply],
+      replyCount: comment.replyCount + 1
+    };
+    const commentsById = new Map(videoState.commentsById);
+    commentsById.set(parentId, updatedComment);
+    this.updateVideoState(videoId, { commentsById });
+  }
+  updateLikeState(videoId, commentId, isLiked, isReply, parentId) {
+    const videoState = this.store.getState().byVideoId.get(videoId);
+    if (!videoState) return;
+    if (isReply && parentId) {
+      const comment = videoState.commentsById.get(parentId);
+      if (!comment) return;
+      const updatedReplies = comment.replies?.map(
+        (r) => r.id === commentId ? { ...r, isLiked, likeCount: r.likeCount + (isLiked ? 1 : -1) } : r
+      );
+      const commentsById = new Map(videoState.commentsById);
+      commentsById.set(parentId, { ...comment, replies: updatedReplies });
+      this.updateVideoState(videoId, { commentsById });
+    } else {
+      const comment = videoState.commentsById.get(commentId);
+      if (!comment) return;
+      const commentsById = new Map(videoState.commentsById);
+      commentsById.set(commentId, {
+        ...comment,
+        isLiked,
+        likeCount: comment.likeCount + (isLiked ? 1 : -1)
+      });
+      this.updateVideoState(videoId, { commentsById });
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE - UTILITY METHODS
+  // ═══════════════════════════════════════════════════════════════
+  updateVideoState(videoId, partial) {
+    const state = this.store.getState();
+    const existing = state.byVideoId.get(videoId) ?? createInitialVideoCommentState();
+    const newByVideoId = new Map(state.byVideoId);
+    newByVideoId.set(videoId, { ...existing, ...partial });
+    this.store.setState({ byVideoId: newByVideoId });
+  }
+  isCacheStale(videoState) {
+    if (videoState.isStale) return true;
+    if (videoState.cachedAt === 0) return true;
+    return Date.now() - videoState.cachedAt > this.config.cacheTTL;
+  }
+  generateOptimisticId() {
+    return `optimistic_${Date.now()}_${++this.optimisticIdCounter}`;
+  }
+  createError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    let code = "UNKNOWN";
+    let recoverable = true;
+    if (err.message.includes("network") || err.message.includes("fetch")) {
+      code = "NETWORK_ERROR";
+    } else if (err.message.includes("timeout")) {
+      code = "TIMEOUT";
+    } else if (err.message.includes("404") || err.message.includes("not found")) {
+      code = "NOT_FOUND";
+      recoverable = false;
+    } else if (err.message.includes("403") || err.message.includes("forbidden")) {
+      code = "FORBIDDEN";
+      recoverable = false;
+    } else if (err.message.includes("429") || err.message.includes("rate limit")) {
+      code = "RATE_LIMITED";
+    } else if (err.message.includes("500") || err.message.includes("server")) {
+      code = "SERVER_ERROR";
+    }
+    return {
+      message: err.message,
+      code,
+      retryCount: 0,
+      recoverable
+    };
+  }
+};
+
+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 };