@xhub-short/core 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,2495 @@
+import { createStore } from 'zustand/vanilla';
+
+// src/feed/FeedManager.ts
+
+// src/feed/types.ts
+var DEFAULT_FEED_CONFIG = {
+  pageSize: 10,
+  maxRetries: 3,
+  retryBaseDelay: 1e3,
+  staleTime: 5 * 60 * 1e3,
+  // 5 minutes
+  enableSWR: true,
+  maxCacheSize: 100,
+  enableGC: true
+};
+
+// src/feed/FeedManager.ts
+var createInitialState = () => ({
+  itemsById: /* @__PURE__ */ new Map(),
+  displayOrder: [],
+  loading: false,
+  loadingMore: false,
+  error: null,
+  cursor: null,
+  hasMore: true,
+  isStale: false,
+  lastFetchTime: null
+});
+var FeedManager = class {
+  constructor(dataSource, config = {}) {
+    this.dataSource = dataSource;
+    /** Abort controller for cancelling in-flight requests */
+    this.abortController = null;
+    /**
+     * Request deduplication: Map of cursor → in-flight Promise
+     * Prevents duplicate API calls for the same cursor
+     */
+    this.inFlightRequests = /* @__PURE__ */ new Map();
+    /**
+     * LRU tracking: Map of videoId → lastAccessTime
+     * Used for garbage collection
+     */
+    this.accessOrder = /* @__PURE__ */ new Map();
+    this.config = { ...DEFAULT_FEED_CONFIG, ...config };
+    this.store = createStore(createInitialState);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Load initial feed data
+   *
+   * Implements SWR pattern:
+   * 1. If cached data exists, show it immediately
+   * 2. If data is stale (>staleTime), revalidate in background
+   * 3. If no cached data, fetch from network
+   *
+   * Request Deduplication:
+   * - 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() {
+    const dedupeKey = "__initial__";
+    const existingRequest = this.inFlightRequests.get(dedupeKey);
+    if (existingRequest) {
+      return existingRequest;
+    }
+    const state = this.store.getState();
+    if (state.loading) {
+      return;
+    }
+    this.store.setState({ loading: true, error: null });
+    const request = this.executeLoadInitial();
+    this.inFlightRequests.set(dedupeKey, request);
+    try {
+      await request;
+    } finally {
+      this.inFlightRequests.delete(dedupeKey);
+    }
+  }
+  /**
+   * Internal: Execute load initial logic
+   */
+  async executeLoadInitial() {
+    try {
+      await this.fetchWithRetry();
+    } catch (error) {
+      this.handleError(error, "loadInitial");
+    } finally {
+      this.store.setState({ loading: false });
+    }
+  }
+  /**
+   * Load more videos (pagination)
+   *
+   * Features:
+   * - Race condition protection (prevents concurrent calls)
+   * - Request deduplication (prevents duplicate API calls for same cursor)
+   * - Exponential backoff retry on failure
+   */
+  async loadMore() {
+    const state = this.store.getState();
+    if (state.loading || state.loadingMore || !state.hasMore) {
+      return;
+    }
+    const cursor = state.cursor ?? "__null__";
+    const dedupeKey = `loadMore:${cursor}`;
+    const existingRequest = this.inFlightRequests.get(dedupeKey);
+    if (existingRequest) {
+      return existingRequest;
+    }
+    this.store.setState({ loadingMore: true, error: null });
+    const request = this.executeLoadMore(state.cursor ?? void 0);
+    this.inFlightRequests.set(dedupeKey, request);
+    try {
+      await request;
+    } finally {
+      this.inFlightRequests.delete(dedupeKey);
+    }
+  }
+  /**
+   * Internal: Execute load more logic
+   */
+  async executeLoadMore(cursor) {
+    try {
+      await this.fetchWithRetry(cursor);
+    } catch (error) {
+      this.handleError(error, "loadMore");
+    } finally {
+      this.store.setState({ loadingMore: false });
+    }
+  }
+  /**
+   * Revalidate feed data in background (SWR pattern)
+   *
+   * Used when cached data is stale but still shown to user
+   */
+  async revalidate() {
+    const state = this.store.getState();
+    if (state.loading || state.loadingMore) {
+      return;
+    }
+    try {
+      const response = await this.dataSource.fetchFeed();
+      this.mergeVideos(response.items, true);
+      this.store.setState({
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        isStale: false,
+        lastFetchTime: Date.now()
+      });
+    } catch {
+    }
+  }
+  /**
+   * 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) {
+      this.accessOrder.set(id, Date.now());
+    }
+    return video;
+  }
+  /**
+   * Get ordered list of videos
+   */
+  getVideos() {
+    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)
+   */
+  updateVideo(id, updates) {
+    const state = this.store.getState();
+    const existing = state.itemsById.get(id);
+    if (existing) {
+      const newItemsById = new Map(state.itemsById);
+      newItemsById.set(id, { ...existing, ...updates });
+      this.store.setState({ itemsById: newItemsById });
+    }
+  }
+  /**
+   * Check if data is stale and needs revalidation
+   */
+  isStale() {
+    const state = this.store.getState();
+    if (!state.lastFetchTime) return true;
+    return Date.now() - state.lastFetchTime > this.config.staleTime;
+  }
+  /**
+   * Reset feed state
+   */
+  reset() {
+    this.cancelPendingRequests();
+    this.inFlightRequests.clear();
+    this.accessOrder.clear();
+    this.store.setState(createInitialState());
+  }
+  /**
+   * Cancel any pending requests
+   */
+  cancelPendingRequests() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  /**
+   * Destroy the manager and cleanup
+   */
+  destroy() {
+    this.cancelPendingRequests();
+    this.inFlightRequests.clear();
+    this.accessOrder.clear();
+    this.store.setState(createInitialState());
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Fetch with exponential backoff retry
+   */
+  async fetchWithRetry(cursor) {
+    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);
+        this.store.setState({
+          cursor: response.nextCursor,
+          hasMore: response.hasMore,
+          isStale: false,
+          lastFetchTime: Date.now(),
+          error: null
+        });
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("Unknown error");
+        if (lastError.name === "AbortError") {
+          throw lastError;
+        }
+        if (attempt < this.config.maxRetries) {
+          const delay = this.config.retryBaseDelay * 2 ** attempt;
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Add videos with deduplication
+   * Triggers garbage collection if cache exceeds maxCacheSize
+   */
+  addVideos(videos) {
+    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);
+      }
+    }
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder
+    });
+    if (this.config.enableGC) {
+      this.runGarbageCollection();
+    }
+  }
+  /**
+   * Merge videos (for SWR revalidation)
+   * Updates existing videos, adds new ones at the beginning
+   */
+  mergeVideos(videos, 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);
+      } else {
+        newItemsById.set(video.id, video);
+        newIds.push(video.id);
+      }
+    }
+    const newDisplayOrder = prepend ? [...newIds, ...state.displayOrder] : [...state.displayOrder, ...newIds];
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder
+    });
+  }
+  /**
+   * Handle and categorize errors
+   */
+  handleError(error, _context) {
+    const feedError = this.categorizeError(error);
+    this.store.setState({ error: feedError });
+  }
+  /**
+   * Categorize error for better error handling
+   */
+  categorizeError(error) {
+    if (error instanceof Error) {
+      const lowerMessage = error.message.toLowerCase();
+      if (error.name === "TypeError" || lowerMessage.includes("network")) {
+        return {
+          message: "Network error. Please check your connection.",
+          code: "NETWORK_ERROR",
+          retryCount: this.config.maxRetries,
+          recoverable: true
+        };
+      }
+      if (error.name === "AbortError" || lowerMessage.includes("timeout")) {
+        return {
+          message: "Request timed out. Please try again.",
+          code: "TIMEOUT",
+          retryCount: this.config.maxRetries,
+          recoverable: true
+        };
+      }
+      if (lowerMessage.includes("500") || lowerMessage.includes("server")) {
+        return {
+          message: "Server error. Please try again later.",
+          code: "SERVER_ERROR",
+          retryCount: this.config.maxRetries,
+          recoverable: true
+        };
+      }
+      return {
+        message: error.message,
+        code: "UNKNOWN",
+        retryCount: this.config.maxRetries,
+        recoverable: false
+      };
+    }
+    return {
+      message: "An unexpected error occurred.",
+      code: "UNKNOWN",
+      retryCount: this.config.maxRetries,
+      recoverable: false
+    };
+  }
+  /**
+   * Sleep utility for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // GARBAGE COLLECTION
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * 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)
+   *
+   * @returns Number of evicted items
+   */
+  runGarbageCollection() {
+    const state = this.store.getState();
+    const currentSize = state.itemsById.size;
+    if (currentSize <= this.config.maxCacheSize) {
+      return 0;
+    }
+    const itemsToEvict = currentSize - this.config.maxCacheSize;
+    const sortedByAccess = Array.from(this.accessOrder.entries()).sort((a, b) => a[1] - b[1]).map(([id]) => id);
+    const minProtected = 3;
+    const protectedCount = Math.max(
+      minProtected,
+      Math.min(this.config.maxCacheSize, state.displayOrder.length)
+    );
+    const protectedIds = new Set(state.displayOrder.slice(-protectedCount));
+    const evictionCandidates = sortedByAccess.filter((id) => !protectedIds.has(id));
+    const actualEvictions = Math.min(itemsToEvict, evictionCandidates.length);
+    const idsToEvict = evictionCandidates.slice(0, actualEvictions);
+    if (idsToEvict.length === 0) {
+      return 0;
+    }
+    const newItemsById = new Map(state.itemsById);
+    const evictedSet = new Set(idsToEvict);
+    for (const id of idsToEvict) {
+      newItemsById.delete(id);
+      this.accessOrder.delete(id);
+    }
+    const newDisplayOrder = state.displayOrder.filter((id) => !evictedSet.has(id));
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder
+    });
+    return idsToEvict.length;
+  }
+  /**
+   * Manually trigger garbage collection
+   * Useful for debugging or when memory pressure is detected
+   *
+   * @returns Number of evicted items
+   */
+  forceGarbageCollection() {
+    return this.runGarbageCollection();
+  }
+  /**
+   * Get current cache statistics
+   * Useful for debugging and monitoring
+   */
+  getCacheStats() {
+    const state = this.store.getState();
+    const accessTimes = Array.from(this.accessOrder.values());
+    return {
+      size: state.itemsById.size,
+      maxSize: this.config.maxCacheSize,
+      utilizationPercent: Math.round(state.itemsById.size / this.config.maxCacheSize * 100),
+      oldestAccessTime: accessTimes.length > 0 ? Math.min(...accessTimes) : null,
+      newestAccessTime: accessTimes.length > 0 ? Math.max(...accessTimes) : null
+    };
+  }
+};
+
+// src/player/types.ts
+var PlayerStatus = /* @__PURE__ */ ((PlayerStatus2) => {
+  PlayerStatus2["IDLE"] = "idle";
+  PlayerStatus2["LOADING"] = "loading";
+  PlayerStatus2["PLAYING"] = "playing";
+  PlayerStatus2["PAUSED"] = "paused";
+  PlayerStatus2["BUFFERING"] = "buffering";
+  PlayerStatus2["ERROR"] = "error";
+  return PlayerStatus2;
+})(PlayerStatus || {});
+var DEFAULT_PLAYER_CONFIG = {
+  autoplay: true,
+  defaultVolume: 1,
+  defaultMuted: true,
+  loop: true,
+  watchTimeThreshold: 3,
+  completionThreshold: 90
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  consecutiveErrorThreshold: 3,
+  resetTimeoutMs: 3e4,
+  // 30 seconds
+  successThreshold: 1,
+  enabled: true
+};
+
+// src/player/state-machine.ts
+var VALID_TRANSITIONS = {
+  ["idle" /* IDLE */]: ["loading" /* LOADING */],
+  ["loading" /* LOADING */]: ["playing" /* PLAYING */, "error" /* ERROR */, "idle" /* IDLE */],
+  ["playing" /* PLAYING */]: [
+    "paused" /* PAUSED */,
+    "buffering" /* BUFFERING */,
+    "error" /* ERROR */,
+    "idle" /* IDLE */
+  ],
+  ["paused" /* PAUSED */]: ["playing" /* PLAYING */, "idle" /* IDLE */, "loading" /* LOADING */],
+  ["buffering" /* BUFFERING */]: ["playing" /* PLAYING */, "error" /* ERROR */, "idle" /* IDLE */],
+  ["error" /* ERROR */]: ["idle" /* IDLE */, "loading" /* LOADING */]
+};
+function isValidTransition(from, to) {
+  if (from === to) return true;
+  const validTargets = VALID_TRANSITIONS[from];
+  return validTargets.includes(to);
+}
+function getInvalidTransitionReason(from, to) {
+  const validTargets = VALID_TRANSITIONS[from];
+  return `Cannot transition from ${from} to ${to}. Valid transitions from ${from}: [${validTargets.join(", ")}]`;
+}
+function isActiveState(status) {
+  return status === "playing" /* PLAYING */ || status === "paused" /* PAUSED */ || status === "buffering" /* BUFFERING */;
+}
+function canPlay(status) {
+  return status === "paused" /* PAUSED */ || status === "loading" /* LOADING */;
+}
+function canPause(status) {
+  return status === "playing" /* PLAYING */ || status === "buffering" /* BUFFERING */;
+}
+function canSeek(status) {
+  return isActiveState(status);
+}
+
+// src/player/PlayerEngine.ts
+var createInitialCircuitBreakerState = () => ({
+  state: "closed" /* CLOSED */,
+  consecutiveErrors: 0,
+  halfOpenSuccesses: 0,
+  openedAt: null,
+  lastError: null
+});
+var createInitialState2 = (config) => ({
+  status: "idle" /* IDLE */,
+  currentVideo: null,
+  currentTime: 0,
+  duration: 0,
+  buffered: 0,
+  volume: config.defaultVolume,
+  muted: config.defaultMuted,
+  playbackRate: 1,
+  loopCount: 0,
+  watchTime: 0,
+  error: null,
+  ended: false
+});
+var PlayerEngine = class {
+  constructor(config = {}) {
+    /** Event listeners */
+    this.eventListeners = /* @__PURE__ */ new Set();
+    /** Watch time tracking interval */
+    this.watchTimeInterval = null;
+    /** Last status for tracking transitions */
+    this.lastStatus = "idle" /* IDLE */;
+    /** Circuit Breaker state */
+    this.circuitBreaker = createInitialCircuitBreakerState();
+    /** Circuit Breaker reset timer */
+    this.circuitResetTimer = null;
+    const { analytics, logger, circuitBreaker, ...restConfig } = config;
+    this.config = { ...DEFAULT_PLAYER_CONFIG, ...restConfig };
+    this.circuitBreakerConfig = { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...circuitBreaker };
+    this.analytics = analytics;
+    this.logger = logger;
+    this.store = createStore(() => createInitialState2(this.config));
+    this.store.subscribe((state) => {
+      if (state.status !== this.lastStatus) {
+        this.emitEvent({
+          type: "statusChange",
+          status: state.status,
+          previousStatus: this.lastStatus
+        });
+        this.lastStatus = state.status;
+      }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - PLAYBACK CONTROL
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Load a video and prepare for playback
+   *
+   * @returns true if load was initiated, false if rejected (circuit open or invalid state)
+   */
+  load(video) {
+    if (!this.checkCircuitBreaker()) {
+      this.logger?.warn("[PlayerEngine] Load rejected - circuit breaker is OPEN");
+      this.emitEvent({ type: "loadRejected", reason: "circuit_open" });
+      if (this.circuitBreaker.lastError) {
+        this.store.setState({ error: this.circuitBreaker.lastError });
+        this.transitionTo("error" /* ERROR */);
+      }
+      return false;
+    }
+    const currentStatus = this.store.getState().status;
+    if (currentStatus !== "idle" /* IDLE */ && currentStatus !== "error" /* ERROR */ && currentStatus !== "paused" /* PAUSED */) {
+      if (!this.transitionTo("idle" /* IDLE */)) {
+        return false;
+      }
+    }
+    if (!this.transitionTo("loading" /* LOADING */)) {
+      return false;
+    }
+    this.store.setState({
+      currentVideo: video,
+      currentTime: 0,
+      duration: video.duration,
+      loopCount: 0,
+      watchTime: 0,
+      error: null,
+      ended: false
+    });
+    this.emitEvent({ type: "videoChange", video });
+    this.logger?.debug(`[PlayerEngine] Loaded video: ${video.id}`);
+    if (this.config.autoplay) {
+      this.onReady();
+    }
+    return true;
+  }
+  /**
+   * Called when video is ready to play (after loading)
+   */
+  onReady() {
+    const state = this.store.getState();
+    if (state.status !== "loading" /* LOADING */) {
+      this.logger?.warn(`[PlayerEngine] onReady called but status is ${state.status}, not LOADING`);
+      return false;
+    }
+    if (!this.transitionTo("playing" /* PLAYING */)) {
+      return false;
+    }
+    this.recordCircuitBreakerSuccess();
+    this.startWatchTimeTracking();
+    return true;
+  }
+  /**
+   * Start or resume playback
+   */
+  play() {
+    const state = this.store.getState();
+    if (!canPlay(state.status)) {
+      this.logger?.warn(`[PlayerEngine] Cannot play in status: ${state.status}`);
+      return false;
+    }
+    if (!this.transitionTo("playing" /* PLAYING */)) {
+      return false;
+    }
+    this.startWatchTimeTracking();
+    this.logger?.debug("[PlayerEngine] Playback started");
+    return true;
+  }
+  /**
+   * Pause playback
+   */
+  pause() {
+    const state = this.store.getState();
+    if (!canPause(state.status)) {
+      this.logger?.warn(`[PlayerEngine] Cannot pause in status: ${state.status}`);
+      return false;
+    }
+    if (!this.transitionTo("paused" /* PAUSED */)) {
+      return false;
+    }
+    this.stopWatchTimeTracking();
+    this.logger?.debug("[PlayerEngine] Playback paused");
+    return true;
+  }
+  /**
+   * Seek to a specific time
+   *
+   * Emits a 'seek' event that VideoPlayer listens to
+   * to apply the seek to the actual video element.
+   */
+  seek(time) {
+    const state = this.store.getState();
+    if (!canSeek(state.status)) {
+      this.logger?.warn(`[PlayerEngine] Cannot seek in status: ${state.status}`);
+      return false;
+    }
+    const clampedTime = Math.max(0, Math.min(time, state.duration));
+    this.store.setState({ currentTime: clampedTime, ended: false });
+    this.emitEvent({ type: "seek", time: clampedTime });
+    this.logger?.debug(`[PlayerEngine] Seeked to: ${clampedTime}s`);
+    return true;
+  }
+  /**
+   * Set volume
+   */
+  setVolume(volume) {
+    const clampedVolume = Math.max(0, Math.min(1, volume));
+    this.store.setState({ volume: clampedVolume });
+  }
+  /**
+   * Toggle mute
+   */
+  setMuted(muted) {
+    this.store.setState({ muted });
+  }
+  /**
+   * Set playback rate
+   */
+  setPlaybackRate(rate) {
+    const clampedRate = Math.max(0.25, Math.min(2, rate));
+    this.store.setState({ playbackRate: clampedRate });
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - VIDEO ELEMENT EVENTS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Handle time update from video element
+   */
+  onTimeUpdate(currentTime) {
+    const state = this.store.getState();
+    this.store.setState({ currentTime });
+    this.emitEvent({
+      type: "timeUpdate",
+      currentTime,
+      duration: state.duration
+    });
+  }
+  /**
+   * Handle duration change from video element
+   *
+   * Called when video metadata is loaded and actual duration is available.
+   * This may differ from the API-provided duration in VideoItem.
+   *
+   * @param duration - Actual video duration in seconds from video element
+   */
+  onDurationChange(duration) {
+    if (duration > 0 && Number.isFinite(duration)) {
+      this.store.setState({ duration });
+      this.logger?.debug(`[PlayerEngine] Duration updated: ${duration}s`);
+    }
+  }
+  /**
+   * Handle buffering start
+   */
+  onBuffering() {
+    const state = this.store.getState();
+    if (state.status === "playing" /* PLAYING */) {
+      this.stopWatchTimeTracking();
+      return this.transitionTo("buffering" /* BUFFERING */);
+    }
+    return false;
+  }
+  /**
+   * Handle buffering end
+   */
+  onBufferingEnd() {
+    const state = this.store.getState();
+    if (state.status === "buffering" /* BUFFERING */) {
+      this.startWatchTimeTracking();
+      return this.transitionTo("playing" /* PLAYING */);
+    }
+    return false;
+  }
+  /**
+   * Handle buffer progress update
+   */
+  onBufferProgress(bufferedPercent) {
+    this.store.setState({ buffered: Math.min(100, Math.max(0, bufferedPercent)) });
+  }
+  /**
+   * Handle video ended
+   */
+  onEnded() {
+    const state = this.store.getState();
+    const newLoopCount = state.loopCount + 1;
+    this.store.setState({
+      loopCount: newLoopCount,
+      ended: true
+    });
+    this.emitEvent({
+      type: "ended",
+      loopCount: newLoopCount,
+      watchTime: state.watchTime
+    });
+    this.trackCompletion(state, newLoopCount);
+    if (this.config.loop) {
+      this.store.setState({ currentTime: 0, ended: false });
+    } else {
+      this.stopWatchTimeTracking();
+      this.transitionTo("paused" /* PAUSED */);
+    }
+    this.logger?.debug("[PlayerEngine] Video ended", {
+      loopCount: newLoopCount,
+      watchTime: state.watchTime
+    });
+  }
+  /**
+   * Handle video error
+   */
+  onError(error, mediaError) {
+    this.stopWatchTimeTracking();
+    const playerError = this.categorizeError(error, mediaError);
+    this.store.setState({ error: playerError });
+    this.transitionTo("error" /* ERROR */);
+    if (playerError.recoverable) {
+      this.recordCircuitBreakerError(playerError);
+    }
+    this.emitEvent({ type: "error", error: playerError });
+    this.logger?.error(`[PlayerEngine] Video error: ${playerError.message}`, error);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Reset player to initial state
+   */
+  reset() {
+    this.stopWatchTimeTracking();
+    this.store.setState(createInitialState2(this.config));
+    this.lastStatus = "idle" /* IDLE */;
+    this.emitEvent({ type: "videoChange", video: null });
+    this.logger?.debug("[PlayerEngine] Player reset");
+  }
+  /**
+   * Destroy player and cleanup
+   */
+  destroy() {
+    this.stopWatchTimeTracking();
+    this.clearCircuitResetTimer();
+    this.eventListeners.clear();
+    this.store.setState(createInitialState2(this.config));
+    this.circuitBreaker = createInitialCircuitBreakerState();
+    this.logger?.debug("[PlayerEngine] Player destroyed");
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // 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);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - GETTERS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return this.store.getState().status;
+  }
+  /**
+   * Get current video
+   */
+  getCurrentVideo() {
+    return this.store.getState().currentVideo;
+  }
+  /**
+   * Check if playing
+   */
+  isPlaying() {
+    return this.store.getState().status === "playing" /* PLAYING */;
+  }
+  /**
+   * Check if paused
+   */
+  isPaused() {
+    return this.store.getState().status === "paused" /* PAUSED */;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Attempt to transition to a new state
+   */
+  transitionTo(newStatus) {
+    const currentStatus = this.store.getState().status;
+    if (!isValidTransition(currentStatus, newStatus)) {
+      const reason = getInvalidTransitionReason(currentStatus, newStatus);
+      this.logger?.warn(`[PlayerEngine] ${reason}`);
+      return false;
+    }
+    this.store.setState({ status: newStatus });
+    return true;
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emitEvent(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        this.logger?.error(
+          "[PlayerEngine] Event listener error",
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    }
+  }
+  /**
+   * Start watch time tracking
+   */
+  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 });
+      }
+    }, 1e3);
+  }
+  /**
+   * Stop watch time tracking
+   */
+  stopWatchTimeTracking() {
+    if (this.watchTimeInterval) {
+      clearInterval(this.watchTimeInterval);
+      this.watchTimeInterval = null;
+    }
+  }
+  /**
+   * Track completion analytics
+   */
+  trackCompletion(state, loopCount) {
+    if (!this.analytics || !state.currentVideo) return;
+    const watchPercentage = state.duration > 0 ? state.watchTime / state.duration * 100 : 0;
+    if (state.watchTime >= this.config.watchTimeThreshold) {
+      this.analytics.trackViewDuration(state.currentVideo.id, state.watchTime, state.duration);
+    }
+    if (watchPercentage >= this.config.completionThreshold) {
+      this.analytics.trackCompletion(state.currentVideo.id, state.watchTime, loopCount);
+    }
+  }
+  /**
+   * Categorize media error
+   */
+  categorizeError(error, mediaError) {
+    if (mediaError) {
+      switch (mediaError.code) {
+        case MediaError.MEDIA_ERR_ABORTED:
+          return {
+            message: "Video playback was aborted.",
+            code: "MEDIA_ERROR",
+            recoverable: true,
+            originalError: error
+          };
+        case MediaError.MEDIA_ERR_NETWORK:
+          return {
+            message: "Network error while loading video.",
+            code: "NETWORK_ERROR",
+            recoverable: true,
+            originalError: error
+          };
+        case MediaError.MEDIA_ERR_DECODE:
+          return {
+            message: "Video decoding error.",
+            code: "DECODE_ERROR",
+            recoverable: false,
+            originalError: error
+          };
+        case MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED:
+          return {
+            message: "Video format not supported.",
+            code: "NOT_SUPPORTED",
+            recoverable: false,
+            originalError: error
+          };
+      }
+    }
+    const lowerMessage = error.message.toLowerCase();
+    if (lowerMessage.includes("network")) {
+      return {
+        message: "Network error occurred.",
+        code: "NETWORK_ERROR",
+        recoverable: true,
+        originalError: error
+      };
+    }
+    return {
+      message: error.message || "An unknown error occurred.",
+      code: "UNKNOWN",
+      recoverable: false,
+      originalError: error
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - CIRCUIT BREAKER
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current circuit breaker state
+   */
+  getCircuitBreakerState() {
+    return { ...this.circuitBreaker };
+  }
+  /**
+   * Check if circuit breaker is open (blocking loads)
+   */
+  isCircuitOpen() {
+    return this.circuitBreaker.state === "open" /* OPEN */;
+  }
+  /**
+   * Manually reset circuit breaker to CLOSED state
+   * Useful for user-triggered retry after showing error UI
+   */
+  resetCircuitBreaker() {
+    this.clearCircuitResetTimer();
+    this.circuitBreaker = createInitialCircuitBreakerState();
+    this.emitEvent({ type: "circuitClosed", reason: "manual" });
+    this.logger?.debug("[PlayerEngine] Circuit breaker manually reset");
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS - CIRCUIT BREAKER
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Check if circuit breaker allows load operation
+   * Also handles OPEN → HALF_OPEN transition based on timeout
+   */
+  checkCircuitBreaker() {
+    if (!this.circuitBreakerConfig.enabled) {
+      return true;
+    }
+    const { state, openedAt } = this.circuitBreaker;
+    const { resetTimeoutMs } = this.circuitBreakerConfig;
+    switch (state) {
+      case "closed" /* CLOSED */:
+        return true;
+      case "open" /* OPEN */:
+        if (openedAt && Date.now() - openedAt >= resetTimeoutMs) {
+          this.transitionToHalfOpen();
+          return true;
+        }
+        return false;
+      // Still in OPEN state, reject
+      case "half_open" /* HALF_OPEN */:
+        return true;
+      default:
+        return true;
+    }
+  }
+  /**
+   * Record a recoverable error for circuit breaker tracking
+   */
+  recordCircuitBreakerError(error) {
+    if (!this.circuitBreakerConfig.enabled) {
+      return;
+    }
+    const { consecutiveErrorThreshold } = this.circuitBreakerConfig;
+    const newConsecutiveErrors = this.circuitBreaker.consecutiveErrors + 1;
+    this.circuitBreaker.consecutiveErrors = newConsecutiveErrors;
+    this.circuitBreaker.lastError = error;
+    this.logger?.debug("[PlayerEngine] Circuit breaker recorded error", {
+      consecutiveErrors: newConsecutiveErrors,
+      threshold: consecutiveErrorThreshold
+    });
+    if (newConsecutiveErrors >= consecutiveErrorThreshold) {
+      this.tripCircuit(error);
+    }
+    if (this.circuitBreaker.state === "half_open" /* HALF_OPEN */) {
+      this.tripCircuit(error);
+    }
+  }
+  /**
+   * Record a successful load for circuit breaker tracking
+   */
+  recordCircuitBreakerSuccess() {
+    if (!this.circuitBreakerConfig.enabled) {
+      return;
+    }
+    const { state } = this.circuitBreaker;
+    const { successThreshold } = this.circuitBreakerConfig;
+    this.circuitBreaker.consecutiveErrors = 0;
+    if (state === "half_open" /* HALF_OPEN */) {
+      this.circuitBreaker.halfOpenSuccesses += 1;
+      this.logger?.debug("[PlayerEngine] Circuit breaker half-open success", {
+        halfOpenSuccesses: this.circuitBreaker.halfOpenSuccesses,
+        threshold: successThreshold
+      });
+      if (this.circuitBreaker.halfOpenSuccesses >= successThreshold) {
+        this.closeCircuit();
+      }
+    }
+  }
+  /**
+   * Trip the circuit breaker (CLOSED/HALF_OPEN → OPEN)
+   */
+  tripCircuit(error) {
+    this.clearCircuitResetTimer();
+    this.circuitBreaker.state = "open" /* OPEN */;
+    this.circuitBreaker.openedAt = Date.now();
+    this.circuitBreaker.halfOpenSuccesses = 0;
+    this.emitEvent({
+      type: "circuitOpened",
+      consecutiveErrors: this.circuitBreaker.consecutiveErrors,
+      lastError: error
+    });
+    this.logger?.warn("[PlayerEngine] Circuit breaker OPENED", {
+      consecutiveErrors: this.circuitBreaker.consecutiveErrors,
+      error: error.message
+    });
+    this.scheduleHalfOpenTransition();
+  }
+  /**
+   * Transition from OPEN to HALF_OPEN
+   */
+  transitionToHalfOpen() {
+    this.circuitBreaker.state = "half_open" /* HALF_OPEN */;
+    this.circuitBreaker.halfOpenSuccesses = 0;
+    this.emitEvent({ type: "circuitHalfOpen" });
+    this.logger?.debug("[PlayerEngine] Circuit breaker transitioned to HALF_OPEN");
+  }
+  /**
+   * Close the circuit breaker (HALF_OPEN → CLOSED)
+   */
+  closeCircuit() {
+    this.clearCircuitResetTimer();
+    this.circuitBreaker = createInitialCircuitBreakerState();
+    this.emitEvent({ type: "circuitClosed", reason: "success" });
+    this.logger?.debug("[PlayerEngine] Circuit breaker CLOSED after successful recovery");
+  }
+  /**
+   * Schedule automatic transition from OPEN to HALF_OPEN
+   */
+  scheduleHalfOpenTransition() {
+    this.clearCircuitResetTimer();
+    this.circuitResetTimer = setTimeout(() => {
+      if (this.circuitBreaker.state === "open" /* OPEN */) {
+        this.transitionToHalfOpen();
+      }
+    }, this.circuitBreakerConfig.resetTimeoutMs);
+  }
+  /**
+   * Clear circuit reset timer
+   */
+  clearCircuitResetTimer() {
+    if (this.circuitResetTimer) {
+      clearTimeout(this.circuitResetTimer);
+      this.circuitResetTimer = null;
+    }
+  }
+};
+
+// src/lifecycle/types.ts
+var DEFAULT_LIFECYCLE_CONFIG = {
+  snapshotExpiryMs: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  revalidationThresholdMs: 5 * 60 * 1e3,
+  // 5 minutes
+  autoSaveOnHidden: true,
+  restorePlaybackPosition: false,
+  // User must opt-in for playback position restore
+  version: "1.0.0"
+};
+
+// src/lifecycle/LifecycleManager.ts
+var createInitialState3 = () => ({
+  isInitialized: false,
+  isSaving: false,
+  isRestoring: false,
+  lastSavedAt: null,
+  lastRestoredAt: null,
+  needsRevalidation: false,
+  visibilityState: typeof document !== "undefined" ? document.visibilityState : "visible"
+});
+var LifecycleManager = class {
+  constructor(config = {}) {
+    /** Event listeners */
+    this.eventListeners = /* @__PURE__ */ new Set();
+    const { storage, logger, ...restConfig } = config;
+    this.config = { ...DEFAULT_LIFECYCLE_CONFIG, ...restConfig };
+    this.storage = storage;
+    this.logger = logger;
+    this.store = createStore(createInitialState3);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Initialize lifecycle manager and attempt to restore session
+   */
+  async initialize() {
+    if (this.store.getState().isInitialized) {
+      this.logger?.warn("[LifecycleManager] Already initialized");
+      return {
+        success: false,
+        snapshot: null,
+        needsRevalidation: false,
+        reason: "error"
+      };
+    }
+    if (this.config.autoSaveOnHidden && typeof document !== "undefined") {
+      this.setupVisibilityListener();
+    }
+    this.store.setState({ isInitialized: true });
+    this.logger?.debug("[LifecycleManager] Initialized");
+    return this.restoreSession();
+  }
+  /**
+   * Destroy lifecycle manager and cleanup
+   */
+  destroy() {
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = void 0;
+    }
+    this.eventListeners.clear();
+    this.store.setState(createInitialState3());
+    this.logger?.debug("[LifecycleManager] Destroyed");
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - SESSION MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Restore session from storage
+   */
+  async restoreSession() {
+    if (!this.storage) {
+      this.logger?.debug("[LifecycleManager] No storage adapter, skipping restore");
+      return {
+        success: false,
+        snapshot: null,
+        needsRevalidation: false,
+        reason: "no_snapshot"
+      };
+    }
+    this.store.setState({ isRestoring: true });
+    this.emitEvent({ type: "restoreStart" });
+    try {
+      const snapshot = await this.storage.loadSnapshot();
+      if (!snapshot) {
+        this.logger?.debug("[LifecycleManager] No snapshot found");
+        const result2 = {
+          success: false,
+          snapshot: null,
+          needsRevalidation: false,
+          reason: "no_snapshot"
+        };
+        this.store.setState({ isRestoring: false });
+        this.emitEvent({ type: "restoreComplete", result: result2 });
+        return result2;
+      }
+      const validationResult = this.validateSnapshot(snapshot);
+      if (!validationResult.valid) {
+        this.logger?.debug(`[LifecycleManager] Invalid snapshot: ${validationResult.reason}`);
+        await this.clearSnapshot();
+        const result2 = {
+          success: false,
+          snapshot: null,
+          needsRevalidation: false,
+          reason: validationResult.reason
+        };
+        this.store.setState({ isRestoring: false });
+        this.emitEvent({ type: "restoreComplete", result: result2 });
+        return result2;
+      }
+      const needsRevalidation = this.isSnapshotStale(snapshot);
+      const validSnapshot = snapshot;
+      const result = {
+        success: true,
+        snapshot: validSnapshot,
+        needsRevalidation
+      };
+      if (this.config.restorePlaybackPosition) {
+        if (validSnapshot.playbackTime !== void 0) {
+          result.playbackTime = validSnapshot.playbackTime;
+        }
+        if (validSnapshot.currentVideoId !== void 0) {
+          result.currentVideoId = validSnapshot.currentVideoId;
+        }
+      }
+      this.store.setState({
+        isRestoring: false,
+        lastRestoredAt: Date.now(),
+        needsRevalidation
+      });
+      this.emitEvent({ type: "restoreComplete", result });
+      this.logger?.debug("[LifecycleManager] Session restored", {
+        itemCount: validSnapshot.items.length,
+        needsRevalidation,
+        hasPlaybackTime: this.config.restorePlaybackPosition && validSnapshot.playbackTime !== void 0
+      });
+      return result;
+    } catch (error) {
+      this.logger?.error(
+        "[LifecycleManager] Restore failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      const result = {
+        success: false,
+        snapshot: null,
+        needsRevalidation: false,
+        reason: "error"
+      };
+      this.store.setState({ isRestoring: false });
+      this.emitEvent({ type: "restoreComplete", result });
+      return result;
+    }
+  }
+  /**
+   * Save session snapshot to storage
+   *
+   * @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)
+   */
+  async saveSnapshot(data) {
+    if (!this.storage) {
+      this.logger?.debug("[LifecycleManager] No storage adapter, skipping save");
+      return false;
+    }
+    if (data.items.length === 0) {
+      this.logger?.debug("[LifecycleManager] No items to save, skipping");
+      return false;
+    }
+    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;
+        }
+      }
+      await this.storage.saveSnapshot(snapshot);
+      const timestamp = Date.now();
+      this.store.setState({
+        isSaving: false,
+        lastSavedAt: timestamp
+      });
+      this.emitEvent({ type: "saveComplete", timestamp });
+      this.logger?.debug("[LifecycleManager] Snapshot saved", {
+        itemCount: data.items.length,
+        hasPlaybackTime: this.config.restorePlaybackPosition && data.playbackTime !== void 0
+      });
+      return true;
+    } catch (error) {
+      this.logger?.error(
+        "[LifecycleManager] Save failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      this.store.setState({ isSaving: false });
+      this.emitEvent({
+        type: "saveFailed",
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return false;
+    }
+  }
+  /**
+   * Clear saved snapshot
+   */
+  async clearSnapshot() {
+    if (!this.storage) return;
+    try {
+      await this.storage.clearSnapshot();
+      this.logger?.debug("[LifecycleManager] Snapshot cleared");
+    } catch (error) {
+      this.logger?.error(
+        "[LifecycleManager] Clear failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  /**
+   * Mark that pending data should be saved (for use with debouncing)
+   *
+   * @param data - Data to save when flush is called
+   */
+  setPendingSave(data) {
+    this.pendingSaveData = data;
+  }
+  /**
+   * Check if restorePlaybackPosition config is enabled
+   * SDK can use this to decide whether to collect playbackTime
+   */
+  isPlaybackPositionRestoreEnabled() {
+    return this.config.restorePlaybackPosition;
+  }
+  /**
+   * Flush pending save (called on visibility hidden)
+   */
+  async flushPendingSave() {
+    if (this.pendingSaveData) {
+      await this.saveSnapshot(this.pendingSaveData);
+      this.pendingSaveData = void 0;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - VISIBILITY
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Handle visibility state change
+   */
+  onVisibilityChange(state) {
+    const previousState = this.store.getState().visibilityState;
+    if (state === previousState) return;
+    this.store.setState({ visibilityState: state });
+    this.emitEvent({ type: "visibilityChange", state });
+    if (state === "hidden" && this.config.autoSaveOnHidden) {
+      this.flushPendingSave();
+    }
+    this.logger?.debug("[LifecycleManager] Visibility changed", { state });
+  }
+  /**
+   * Get current visibility state
+   */
+  getVisibilityState() {
+    return this.store.getState().visibilityState;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // 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
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Setup visibility change listener
+   */
+  setupVisibilityListener() {
+    this.visibilityHandler = () => {
+      this.onVisibilityChange(document.visibilityState);
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  /**
+   * Validate snapshot data
+   */
+  validateSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object") {
+      return { valid: false, reason: "invalid" };
+    }
+    const s = snapshot;
+    if (!Array.isArray(s.items)) {
+      return { valid: false, reason: "invalid" };
+    }
+    if (typeof s.savedAt !== "number") {
+      return { valid: false, reason: "invalid" };
+    }
+    if (Date.now() - s.savedAt > this.config.snapshotExpiryMs) {
+      return { valid: false, reason: "expired" };
+    }
+    return { valid: true };
+  }
+  /**
+   * Check if snapshot is stale (needs revalidation)
+   */
+  isSnapshotStale(snapshot) {
+    return Date.now() - snapshot.savedAt > this.config.revalidationThresholdMs;
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emitEvent(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        this.logger?.error(
+          "[LifecycleManager] Event listener error",
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    }
+  }
+};
+
+// src/resource/allocation.ts
+function calculateWindowIndices(focusedIndex, totalItems, maxAllocations = 3) {
+  if (totalItems === 0) return [];
+  const indices = [];
+  const clampedFocus = Math.max(0, Math.min(focusedIndex, totalItems - 1));
+  indices.push(clampedFocus);
+  if (clampedFocus > 0 && indices.length < maxAllocations) {
+    indices.push(clampedFocus - 1);
+  }
+  if (clampedFocus < totalItems - 1 && indices.length < maxAllocations) {
+    indices.push(clampedFocus + 1);
+  }
+  return indices.sort((a, b) => a - b);
+}
+function calculatePrefetchIndices(focusedIndex, totalItems, prefetchCount, windowIndices) {
+  if (totalItems === 0 || prefetchCount === 0) return [];
+  const windowSet = new Set(windowIndices);
+  const prefetchIndices = [];
+  for (let i = 1; i <= prefetchCount; i++) {
+    const index = focusedIndex + i;
+    if (index < totalItems && !windowSet.has(index)) {
+      prefetchIndices.push(index);
+    }
+  }
+  return prefetchIndices;
+}
+function computeAllocationChanges(currentAllocations, desiredAllocations) {
+  const desiredSet = new Set(desiredAllocations);
+  const toUnmount = [];
+  for (const index of currentAllocations) {
+    if (!desiredSet.has(index)) {
+      toUnmount.push(index);
+    }
+  }
+  const toMount = [];
+  for (const index of desiredAllocations) {
+    if (!currentAllocations.has(index)) {
+      toMount.push(index);
+    }
+  }
+  return {
+    toMount: toMount.sort((a, b) => a - b),
+    toUnmount: toUnmount.sort((a, b) => a - b),
+    activeAllocations: desiredAllocations
+  };
+}
+
+// src/resource/types.ts
+function mapNetworkType(type) {
+  switch (type) {
+    case "wifi":
+      return "wifi";
+    case "cellular":
+    case "4g":
+    case "3g":
+    case "slow":
+      return "cellular";
+    case "offline":
+      return "offline";
+    default:
+      return "wifi";
+  }
+}
+var DEFAULT_SCROLL_THRASHING_CONFIG = {
+  windowMs: 1e3,
+  maxChangesInWindow: 3,
+  cooldownMs: 500
+};
+var DEFAULT_PREFETCH_CONFIG = {
+  wifi: {
+    posterCount: 5,
+    videoSegmentCount: 2,
+    prefetchVideo: true
+  },
+  cellular: {
+    posterCount: 3,
+    videoSegmentCount: 1,
+    prefetchVideo: true
+  },
+  offline: {
+    posterCount: 1,
+    videoSegmentCount: 0,
+    prefetchVideo: false
+  }
+};
+var DEFAULT_RESOURCE_CONFIG = {
+  maxAllocations: 3,
+  focusDebounceMs: 150,
+  prefetch: DEFAULT_PREFETCH_CONFIG,
+  scrollThrashing: DEFAULT_SCROLL_THRASHING_CONFIG
+};
+
+// src/resource/ResourceGovernor.ts
+var createInitialState4 = () => ({
+  activeAllocations: /* @__PURE__ */ new Set(),
+  preloadQueue: [],
+  focusedIndex: 0,
+  networkType: "wifi",
+  totalItems: 0,
+  isActive: false,
+  isThrottled: false,
+  preloadingIndices: /* @__PURE__ */ new Set()
+});
+var ResourceGovernor = class {
+  constructor(config = {}) {
+    /** Event listeners */
+    this.eventListeners = /* @__PURE__ */ new Set();
+    /** Focus debounce timer */
+    this.focusDebounceTimer = null;
+    /** Pending focused index (before debounce completes) */
+    this.pendingFocusedIndex = null;
+    /** Scroll thrashing detection - timestamps of recent focus changes */
+    this.focusChangeTimestamps = [];
+    /** Scroll thrashing cooldown timer */
+    this.thrashingCooldownTimer = null;
+    const {
+      networkAdapter,
+      videoLoader,
+      posterLoader,
+      logger,
+      prefetch,
+      scrollThrashing,
+      ...restConfig
+    } = config;
+    this.config = {
+      ...DEFAULT_RESOURCE_CONFIG,
+      ...restConfig,
+      prefetch: {
+        wifi: { ...DEFAULT_PREFETCH_CONFIG.wifi, ...prefetch?.wifi },
+        cellular: { ...DEFAULT_PREFETCH_CONFIG.cellular, ...prefetch?.cellular },
+        offline: { ...DEFAULT_PREFETCH_CONFIG.offline, ...prefetch?.offline }
+      },
+      scrollThrashing: {
+        ...DEFAULT_SCROLL_THRASHING_CONFIG,
+        ...scrollThrashing
+      }
+    };
+    this.networkAdapter = networkAdapter;
+    this.videoLoader = videoLoader;
+    this.posterLoader = posterLoader;
+    this.logger = logger;
+    this.store = createStore(createInitialState4);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Activate the resource governor
+   * Starts network monitoring and performs initial allocation
+   */
+  async activate() {
+    if (this.store.getState().isActive) return;
+    this.store.setState({ isActive: true });
+    await this.initializeNetwork();
+    this.performAllocation(this.store.getState().focusedIndex);
+    this.logger?.debug("[ResourceGovernor] Activated");
+  }
+  /**
+   * Deactivate the resource governor
+   * Stops network monitoring and clears allocations
+   */
+  deactivate() {
+    if (!this.store.getState().isActive) return;
+    if (this.focusDebounceTimer) {
+      clearTimeout(this.focusDebounceTimer);
+      this.focusDebounceTimer = null;
+    }
+    if (this.thrashingCooldownTimer) {
+      clearTimeout(this.thrashingCooldownTimer);
+      this.thrashingCooldownTimer = null;
+    }
+    this.focusChangeTimestamps = [];
+    if (this.networkUnsubscribe) {
+      this.networkUnsubscribe();
+      this.networkUnsubscribe = void 0;
+    }
+    const state = this.store.getState();
+    if (this.videoLoader) {
+      for (const index of state.preloadingIndices) {
+        const videoInfo = this.videoSourceGetter?.(index);
+        if (videoInfo) {
+          this.videoLoader.cancelPreload(videoInfo.id);
+        }
+      }
+    }
+    if (state.activeAllocations.size > 0) {
+      this.emitEvent({
+        type: "allocationChange",
+        toMount: [],
+        toUnmount: [...state.activeAllocations]
+      });
+    }
+    this.store.setState(createInitialState4());
+    this.logger?.debug("[ResourceGovernor] Deactivated");
+  }
+  /**
+   * Destroy the resource governor
+   */
+  destroy() {
+    this.deactivate();
+    this.eventListeners.clear();
+    this.logger?.debug("[ResourceGovernor] Destroyed");
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - FEED MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Set total number of items in feed
+   */
+  setTotalItems(count) {
+    const state = this.store.getState();
+    if (state.totalItems === count) return;
+    this.store.setState({ totalItems: count });
+    if (state.isActive) {
+      this.performAllocation(state.focusedIndex);
+    }
+  }
+  /**
+   * Set focused index with debouncing
+   * This is called during scroll/swipe
+   */
+  setFocusedIndex(index) {
+    const state = this.store.getState();
+    const clampedIndex = Math.max(0, Math.min(index, state.totalItems - 1));
+    if (clampedIndex === state.focusedIndex && this.pendingFocusedIndex === null) {
+      return;
+    }
+    this.pendingFocusedIndex = clampedIndex;
+    this.trackFocusChange();
+    if (this.focusDebounceTimer) {
+      clearTimeout(this.focusDebounceTimer);
+    }
+    this.focusDebounceTimer = setTimeout(() => {
+      this.focusDebounceTimer = null;
+      if (this.pendingFocusedIndex !== null) {
+        const previousIndex = this.store.getState().focusedIndex;
+        const newIndex = this.pendingFocusedIndex;
+        this.pendingFocusedIndex = null;
+        this.store.setState({ focusedIndex: newIndex });
+        this.emitEvent({
+          type: "focusChange",
+          index: newIndex,
+          previousIndex
+        });
+        if (this.store.getState().isActive) {
+          this.performAllocation(newIndex);
+        }
+      }
+    }, this.config.focusDebounceMs);
+  }
+  /**
+   * Set focused index immediately (skip debounce)
+   * Use this for programmatic navigation, not scroll
+   */
+  setFocusedIndexImmediate(index) {
+    const state = this.store.getState();
+    const clampedIndex = Math.max(0, Math.min(index, state.totalItems - 1));
+    if (this.focusDebounceTimer) {
+      clearTimeout(this.focusDebounceTimer);
+      this.focusDebounceTimer = null;
+    }
+    this.pendingFocusedIndex = null;
+    const previousIndex = state.focusedIndex;
+    if (clampedIndex !== previousIndex) {
+      this.store.setState({ focusedIndex: clampedIndex });
+      this.emitEvent({
+        type: "focusChange",
+        index: clampedIndex,
+        previousIndex
+      });
+      if (state.isActive) {
+        this.performAllocation(clampedIndex);
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - ALLOCATION
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Request allocation for given indices
+   * Returns what needs to be mounted/unmounted
+   */
+  requestAllocation(indices) {
+    const state = this.store.getState();
+    const validIndices = indices.filter((i) => i >= 0 && i < state.totalItems);
+    const limitedIndices = validIndices.slice(0, this.config.maxAllocations);
+    const changes = computeAllocationChanges(state.activeAllocations, limitedIndices);
+    this.store.setState({ activeAllocations: new Set(limitedIndices) });
+    if (changes.toMount.length > 0 || changes.toUnmount.length > 0) {
+      this.emitEvent({
+        type: "allocationChange",
+        toMount: changes.toMount,
+        toUnmount: changes.toUnmount
+      });
+    }
+    return { ...changes, success: true };
+  }
+  /**
+   * Get current active allocations
+   */
+  getActiveAllocations() {
+    return [...this.store.getState().activeAllocations];
+  }
+  /**
+   * Check if an index is currently allocated
+   */
+  isAllocated(index) {
+    return this.store.getState().activeAllocations.has(index);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - NETWORK
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current network type
+   */
+  getNetworkType() {
+    return this.store.getState().networkType;
+  }
+  /**
+   * Get prefetch configuration for current network
+   */
+  getPrefetchConfig() {
+    const networkType = this.store.getState().networkType;
+    return this.config.prefetch[networkType];
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - PRELOAD
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Set video source getter function
+   * This is called by SDK to provide video data for preloading
+   *
+   * @param getter - Function that returns video info for a given index
+   */
+  setVideoSourceGetter(getter) {
+    this.videoSourceGetter = getter;
+    this.logger?.debug("[ResourceGovernor] Video source getter set");
+  }
+  /**
+   * Check if preloading is currently throttled due to scroll thrashing
+   */
+  isPreloadThrottled() {
+    return this.store.getState().isThrottled;
+  }
+  /**
+   * Get indices currently being preloaded
+   */
+  getPreloadingIndices() {
+    return [...this.store.getState().preloadingIndices];
+  }
+  /**
+   * Manually trigger preload for specific indices
+   * Respects throttling and network conditions
+   */
+  async triggerPreload(indices) {
+    const state = this.store.getState();
+    if (state.isThrottled || !state.isActive) {
+      this.logger?.debug("[ResourceGovernor] Preload skipped - throttled or inactive");
+      return;
+    }
+    const prefetchConfig = this.getPrefetchConfig();
+    if (!prefetchConfig.prefetchVideo) {
+      this.logger?.debug("[ResourceGovernor] Preload skipped - network does not allow");
+      return;
+    }
+    await this.executePreload(indices);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // 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
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Initialize network detection
+   */
+  async initializeNetwork() {
+    if (!this.networkAdapter) {
+      this.store.setState({ networkType: "wifi" });
+      return;
+    }
+    try {
+      const rawNetworkType = await this.networkAdapter.getNetworkType();
+      const networkType = mapNetworkType(rawNetworkType);
+      this.store.setState({ networkType });
+      this.networkUnsubscribe = this.networkAdapter.onNetworkChange((type) => {
+        const newType = mapNetworkType(type);
+        const previousType = this.store.getState().networkType;
+        if (newType !== previousType) {
+          this.store.setState({ networkType: newType });
+          this.emitEvent({ type: "networkChange", networkType: newType });
+          this.updatePrefetchQueue();
+        }
+      });
+    } catch {
+      this.logger?.warn("[ResourceGovernor] Failed to detect network, defaulting to wifi");
+      this.store.setState({ networkType: "wifi" });
+    }
+  }
+  /**
+   * Perform allocation for a given focused index
+   */
+  performAllocation(focusedIndex) {
+    const state = this.store.getState();
+    const windowIndices = calculateWindowIndices(
+      focusedIndex,
+      state.totalItems,
+      this.config.maxAllocations
+    );
+    this.requestAllocation(windowIndices);
+    this.updatePrefetchQueue();
+  }
+  /**
+   * Update prefetch queue based on current state
+   */
+  updatePrefetchQueue() {
+    const state = this.store.getState();
+    const prefetchConfig = this.getPrefetchConfig();
+    const posterPrefetchIndices = calculatePrefetchIndices(
+      state.focusedIndex,
+      state.totalItems,
+      prefetchConfig.posterCount,
+      [...state.activeAllocations]
+    );
+    const videoPrefetchIndices = calculatePrefetchIndices(
+      state.focusedIndex,
+      state.totalItems,
+      prefetchConfig.videoSegmentCount,
+      [...state.activeAllocations]
+    );
+    if (posterPrefetchIndices.length > 0) {
+      this.store.setState({ preloadQueue: posterPrefetchIndices });
+      this.emitEvent({ type: "prefetchRequest", indices: posterPrefetchIndices });
+      if (!state.isThrottled && prefetchConfig.prefetchVideo) {
+        this.executePreload(videoPrefetchIndices);
+      }
+      this.executePreloadPosters(posterPrefetchIndices);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS - SCROLL THRASHING
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Track focus change timestamp for scroll thrashing detection
+   */
+  trackFocusChange() {
+    const now = Date.now();
+    const { windowMs, maxChangesInWindow, cooldownMs } = this.config.scrollThrashing;
+    this.focusChangeTimestamps.push(now);
+    const windowStart = now - windowMs;
+    this.focusChangeTimestamps = this.focusChangeTimestamps.filter((t) => t >= windowStart);
+    const isCurrentlyThrashing = this.focusChangeTimestamps.length > maxChangesInWindow;
+    const wasThrottled = this.store.getState().isThrottled;
+    if (isCurrentlyThrashing && !wasThrottled) {
+      this.store.setState({ isThrottled: true });
+      this.logger?.debug(
+        `[ResourceGovernor] Scroll thrashing detected (${this.focusChangeTimestamps.length} changes in ${windowMs}ms) - throttling preload`
+      );
+      this.cancelAllPreloads();
+      if (this.thrashingCooldownTimer) {
+        clearTimeout(this.thrashingCooldownTimer);
+      }
+    }
+    if (wasThrottled || isCurrentlyThrashing) {
+      if (this.thrashingCooldownTimer) {
+        clearTimeout(this.thrashingCooldownTimer);
+      }
+      this.thrashingCooldownTimer = setTimeout(() => {
+        this.thrashingCooldownTimer = null;
+        this.store.setState({ isThrottled: false });
+        this.logger?.debug(
+          "[ResourceGovernor] Scroll thrashing cooldown complete - resuming preload"
+        );
+        if (this.store.getState().isActive) {
+          this.updatePrefetchQueue();
+        }
+      }, cooldownMs);
+    }
+  }
+  /**
+   * Cancel all in-progress preloads
+   */
+  cancelAllPreloads() {
+    if (!this.videoLoader) return;
+    const state = this.store.getState();
+    for (const index of state.preloadingIndices) {
+      const videoInfo = this.videoSourceGetter?.(index);
+      if (videoInfo) {
+        this.videoLoader.cancelPreload(videoInfo.id);
+        this.logger?.debug(`[ResourceGovernor] Cancelled preload for index ${index}`);
+      }
+    }
+    this.store.setState({ preloadingIndices: /* @__PURE__ */ new Set() });
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS - PRELOADING
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Execute video preloading for given indices
+   */
+  async executePreload(indices) {
+    if (!this.videoLoader || !this.videoSourceGetter) {
+      return;
+    }
+    const state = this.store.getState();
+    const indicesToPreload = indices.filter((index) => {
+      const videoInfo = this.videoSourceGetter?.(index);
+      if (!videoInfo) return false;
+      if (state.preloadingIndices.has(index)) return false;
+      if (this.videoLoader?.isPreloaded(videoInfo.id)) return false;
+      return true;
+    });
+    if (indicesToPreload.length === 0) return;
+    const newPreloadingIndices = new Set(state.preloadingIndices);
+    for (const index of indicesToPreload) {
+      newPreloadingIndices.add(index);
+    }
+    this.store.setState({ preloadingIndices: newPreloadingIndices });
+    const preloadPromises = indicesToPreload.map(async (index) => {
+      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] 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))
+        );
+      } finally {
+        const currentState = this.store.getState();
+        const updatedPreloadingIndices = new Set(currentState.preloadingIndices);
+        updatedPreloadingIndices.delete(index);
+        this.store.setState({ preloadingIndices: updatedPreloadingIndices });
+      }
+    });
+    await Promise.allSettled(preloadPromises);
+  }
+  /**
+   * Execute poster preloading for given indices
+   */
+  async executePreloadPosters(indices) {
+    if (!this.posterLoader || !this.videoSourceGetter) {
+      return;
+    }
+    const preloadPromises = indices.map(async (index) => {
+      const videoInfo = this.videoSourceGetter?.(index);
+      if (!videoInfo?.poster) return;
+      if (this.posterLoader?.isCached(videoInfo.poster)) return;
+      try {
+        await this.posterLoader?.preload(videoInfo.poster);
+        this.logger?.debug(`[ResourceGovernor] Poster preloaded for index ${index}`);
+      } catch {
+      }
+    });
+    await Promise.allSettled(preloadPromises);
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emitEvent(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        this.logger?.error(
+          "[ResourceGovernor] Event listener error",
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    }
+  }
+};
+
+// src/optimistic/types.ts
+var DEFAULT_OPTIMISTIC_CONFIG = {
+  maxRetries: 3,
+  retryDelayMs: 1e3,
+  autoRetry: true
+};
+
+// src/optimistic/OptimisticManager.ts
+var generateActionId = () => {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+};
+var createInitialState5 = () => ({
+  pendingActions: /* @__PURE__ */ new Map(),
+  failedQueue: [],
+  hasPending: false,
+  isRetrying: false
+});
+var OptimisticManager = class {
+  constructor(config = {}) {
+    /** Event listeners */
+    this.eventListeners = /* @__PURE__ */ new Set();
+    /** Retry timer */
+    this.retryTimer = null;
+    const { interaction, feedManager, logger, ...restConfig } = config;
+    this.config = { ...DEFAULT_OPTIMISTIC_CONFIG, ...restConfig };
+    this.interaction = interaction;
+    this.feedManager = feedManager;
+    this.logger = logger;
+    this.store = createStore(createInitialState5);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - ACTIONS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Like a video with optimistic update
+   */
+  async like(videoId) {
+    return this.performAction("like", videoId, async () => {
+      if (!this.interaction) throw new Error("No interaction adapter");
+      await this.interaction.like(videoId);
+    });
+  }
+  /**
+   * Unlike a video with optimistic update
+   */
+  async unlike(videoId) {
+    return this.performAction("unlike", videoId, async () => {
+      if (!this.interaction) throw new Error("No interaction adapter");
+      await this.interaction.unlike(videoId);
+    });
+  }
+  /**
+   * Toggle like state (like if not liked, unlike if liked)
+   */
+  async toggleLike(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);
+  }
+  /**
+   * Follow a video author with optimistic update
+   */
+  async follow(videoId) {
+    return this.performAction("follow", videoId, async () => {
+      if (!this.interaction) throw new Error("No interaction adapter");
+      await this.interaction.follow(videoId);
+    });
+  }
+  /**
+   * Unfollow a video author with optimistic update
+   */
+  async unfollow(videoId) {
+    return this.performAction("unfollow", videoId, async () => {
+      if (!this.interaction) throw new Error("No interaction adapter");
+      await this.interaction.unfollow(videoId);
+    });
+  }
+  /**
+   * Toggle follow 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);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - STATE MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get all pending actions
+   */
+  getPendingActions() {
+    return [...this.store.getState().pendingActions.values()];
+  }
+  /**
+   * Check if there's a pending action for a video
+   */
+  hasPendingAction(videoId, type) {
+    const actions = this.store.getState().pendingActions;
+    for (const action of actions.values()) {
+      if (action.videoId === videoId && (!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) {
+        await this.retryAction(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);
+      if (action) {
+        this.applyRollback(action);
+        newPendingActions.delete(actionId);
+      }
+    }
+    this.store.setState({
+      pendingActions: newPendingActions,
+      failedQueue: [],
+      hasPending: newPendingActions.size > 0
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PUBLIC API - LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Reset manager state
+   */
+  reset() {
+    this.cancelRetryTimer();
+    this.store.setState(createInitialState5());
+  }
+  /**
+   * Destroy manager and cleanup
+   */
+  destroy() {
+    this.cancelRetryTimer();
+    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
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * 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;
+    }
+    const video = this.feedManager?.getVideo(videoId);
+    if (!video) {
+      this.logger?.warn(`[OptimisticManager] Video not found: ${videoId}`);
+      return false;
+    }
+    const action = {
+      id: generateActionId(),
+      type,
+      videoId,
+      rollbackData: this.createRollbackData(type, video),
+      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}`);
+    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();
+      }
+      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 {};
+    }
+  }
+  /**
+   * Apply optimistic update to feed
+   */
+  applyOptimisticUpdate(type, video) {
+    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;
+    }
+  }
+  /**
+   * Apply rollback
+   */
+  applyRollback(action) {
+    if (!this.feedManager) return;
+    this.feedManager.updateVideo(action.videoId, action.rollbackData);
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+    const video = this.feedManager?.getVideo(action.videoId);
+    if (video) {
+      this.applyOptimisticUpdate(action.type, video);
+    }
+    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);
+      }
+      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;
+    }
+  }
+  /**
+   * Schedule retry of failed actions
+   */
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      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))
+        );
+      }
+    }
+  }
+};
+
+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 };