@xhub-reels/sdk 0.1.7

package/dist/index.cjs

@@ -0,0 +1,2891 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var Hls = require('hls.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Hls__default = /*#__PURE__*/_interopDefault(Hls);
+
+// src/types/content.ts
+function isVideoItem(item) {
+  return item.type === "video";
+}
+function isArticle(item) {
+  return item.type === "article";
+}
+
+// src/types/feed.ts
+var DEFAULT_FEED_CONFIG = {
+  pageSize: 10,
+  maxRetries: 3,
+  retryDelay: 1e3,
+  maxCacheSize: 50,
+  staleTTL: 5 * 60 * 1e3
+};
+
+// src/types/player.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 = {
+  defaultVolume: 1,
+  defaultMuted: true,
+  circuitBreakerThreshold: 3,
+  circuitBreakerResetMs: 1e4
+};
+
+// src/domain/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;
+  return VALID_TRANSITIONS[from].includes(to);
+}
+function canPlay(status) {
+  return status === "paused" /* PAUSED */ || status === "loading" /* LOADING */;
+}
+function canPause(status) {
+  return status === "playing" /* PLAYING */ || status === "buffering" /* BUFFERING */;
+}
+function canSeek(status) {
+  return status === "playing" /* PLAYING */ || status === "paused" /* PAUSED */ || status === "buffering" /* BUFFERING */;
+}
+
+// src/domain/PlayerEngine.ts
+function createInitialCircuit() {
+  return {
+    state: "closed" /* CLOSED */,
+    consecutiveErrors: 0,
+    openedAt: null,
+    lastError: null
+  };
+}
+function createInitialState(muted, volume) {
+  return {
+    status: "idle" /* IDLE */,
+    currentVideo: null,
+    currentVideoId: null,
+    currentTime: 0,
+    duration: 0,
+    buffered: 0,
+    volume,
+    muted,
+    playbackRate: 1,
+    loopCount: 0,
+    watchTime: 0,
+    error: null,
+    ended: false,
+    pendingRestoreTime: null,
+    pendingRestoreVideoId: null
+  };
+}
+var PlayerEngine = class {
+  constructor(config = {}, analytics, logger) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.circuit = createInitialCircuit();
+    this.circuitResetTimer = null;
+    this.watchTimeInterval = null;
+    this.lastStatus = "idle" /* IDLE */;
+    this.config = { ...DEFAULT_PLAYER_CONFIG, ...config };
+    this.analytics = analytics;
+    this.logger = logger;
+    this.store = vanilla.createStore(
+      () => createInitialState(this.config.defaultMuted, this.config.defaultVolume)
+    );
+    this.store.subscribe((state) => {
+      if (state.status !== this.lastStatus) {
+        this.emit({
+          type: "statusChange",
+          status: state.status,
+          previousStatus: this.lastStatus
+        });
+        this.lastStatus = state.status;
+      }
+    });
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Playback Control
+  // ═══════════════════════════════════════════
+  /**
+   * Load a video and prepare for playback.
+   * Returns false if rejected by circuit breaker or invalid state.
+   */
+  load(video) {
+    if (!this.checkCircuit()) {
+      this.logger?.warn("[PlayerEngine] Load rejected \u2014 circuit OPEN");
+      this.emit({ type: "loadRejected", reason: "circuit_open" });
+      if (this.circuit.lastError) {
+        this.store.setState({ error: this.circuit.lastError });
+        this.transition("error" /* ERROR */);
+      }
+      return false;
+    }
+    const { status, currentVideo } = this.store.getState();
+    if (currentVideo && currentVideo.id !== video.id) {
+      this.trackLeave(this.store.getState());
+    }
+    if (status !== "idle" /* IDLE */ && status !== "error" /* ERROR */ && status !== "paused" /* PAUSED */) {
+      if (!this.transition("idle" /* IDLE */)) return false;
+    }
+    if (!this.transition("loading" /* LOADING */)) return false;
+    this.store.setState({
+      currentVideo: video,
+      currentVideoId: video.id,
+      currentTime: 0,
+      duration: video.duration,
+      loopCount: 0,
+      watchTime: 0,
+      error: null,
+      ended: false,
+      // Persist playback speed across videos
+      playbackRate: this.store.getState().playbackRate
+    });
+    this.emit({ type: "videoChange", video });
+    this.logger?.debug(`[PlayerEngine] Loaded: ${video.id}`);
+    return true;
+  }
+  play() {
+    const { status } = this.store.getState();
+    if (!canPlay(status)) {
+      this.logger?.warn(`[PlayerEngine] Cannot play from ${status}`);
+      return false;
+    }
+    this.startWatchTime();
+    return this.transition("playing" /* PLAYING */);
+  }
+  pause() {
+    const { status } = this.store.getState();
+    if (!canPause(status)) return false;
+    this.stopWatchTime();
+    return this.transition("paused" /* PAUSED */);
+  }
+  togglePlay() {
+    const { status } = this.store.getState();
+    if (status === "playing" /* PLAYING */ || status === "buffering" /* BUFFERING */) {
+      return this.pause();
+    }
+    return this.play();
+  }
+  seek(time) {
+    const { status, duration } = this.store.getState();
+    if (!canSeek(status)) return false;
+    const clamped = Math.max(0, Math.min(time, duration));
+    this.store.setState({ currentTime: clamped });
+    this.analytics?.trackPlaybackEvent(
+      this.store.getState().currentVideoId ?? "",
+      "seek",
+      clamped
+    );
+    return true;
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Volume
+  // ═══════════════════════════════════════════
+  setMuted(muted) {
+    this.store.setState({ muted });
+  }
+  toggleMute() {
+    this.store.setState((s) => ({ muted: !s.muted }));
+  }
+  setVolume(volume) {
+    this.store.setState({ volume: Math.max(0, Math.min(1, volume)) });
+  }
+  setPlaybackRate(rate) {
+    this.store.setState({ playbackRate: rate });
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Video Element Event Handlers
+  // ═══════════════════════════════════════════
+  /** Called when <video> fires `canplay` */
+  onCanPlay() {
+    const { status } = this.store.getState();
+    if (status === "loading" /* LOADING */ || status === "buffering" /* BUFFERING */) {
+      this.circuit.consecutiveErrors = 0;
+      this.play();
+    }
+  }
+  /** Called when <video> fires `waiting` */
+  onWaiting() {
+    const { status } = this.store.getState();
+    if (status !== "playing" /* PLAYING */) return false;
+    this.stopWatchTime();
+    return this.transition("buffering" /* BUFFERING */);
+  }
+  /** Called when <video> fires `playing` (after buffering) */
+  onPlaying() {
+    const { status } = this.store.getState();
+    if (status !== "buffering" /* BUFFERING */ && status !== "loading" /* LOADING */) return false;
+    this.startWatchTime();
+    return this.transition("playing" /* PLAYING */);
+  }
+  /** Called when <video> fires `timeupdate` */
+  onTimeUpdate(currentTime) {
+    this.store.setState({ currentTime });
+  }
+  /** Called when <video> fires `progress` (buffer update) */
+  onProgress(buffered) {
+    this.store.setState({ buffered });
+  }
+  /** Called when <video> fires `loadedmetadata` */
+  onLoadedMetadata(duration) {
+    this.store.setState({ duration });
+  }
+  /** Called when <video> fires `ended` */
+  onEnded() {
+    const state = this.store.getState();
+    this.stopWatchTime();
+    this.store.setState((s) => ({
+      ended: true,
+      loopCount: s.loopCount + 1
+    }));
+    this.analytics?.trackView(state.currentVideoId ?? "", state.watchTime);
+    this.emit({
+      type: "ended",
+      videoId: state.currentVideoId ?? "",
+      watchTime: state.watchTime,
+      loopCount: state.loopCount + 1
+    });
+  }
+  /** Called when <video> fires `error` */
+  onError(code, message) {
+    const error = {
+      code,
+      message,
+      recoverable: code !== "DECODE_ERROR" && code !== "NOT_SUPPORTED"
+    };
+    this.stopWatchTime();
+    this.recordCircuitError(error);
+    this.store.setState({ error });
+    this.transition("error" /* ERROR */);
+    this.emit({ type: "error", error });
+    this.analytics?.trackError(this.store.getState().currentVideoId ?? "", message);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Session Restore
+  // ═══════════════════════════════════════════
+  setPendingRestore(videoId, time) {
+    this.store.setState({
+      pendingRestoreVideoId: videoId,
+      pendingRestoreTime: time
+    });
+  }
+  consumePendingRestore(videoId) {
+    const { pendingRestoreVideoId, pendingRestoreTime } = this.store.getState();
+    if (pendingRestoreVideoId === videoId && pendingRestoreTime !== null) {
+      this.store.setState({ pendingRestoreTime: null, pendingRestoreVideoId: null });
+      return pendingRestoreTime;
+    }
+    return null;
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Events
+  // ═══════════════════════════════════════════
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Lifecycle
+  // ═══════════════════════════════════════════
+  reset() {
+    this.stopWatchTime();
+    this.store.setState(
+      createInitialState(this.config.defaultMuted, this.config.defaultVolume)
+    );
+    this.lastStatus = "idle" /* IDLE */;
+  }
+  destroy() {
+    this.stopWatchTime();
+    if (this.circuitResetTimer) clearTimeout(this.circuitResetTimer);
+    this.listeners.clear();
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — State Machine
+  // ═══════════════════════════════════════════
+  transition(to) {
+    const from = this.store.getState().status;
+    if (!isValidTransition(from, to)) {
+      this.logger?.warn(`[PlayerEngine] Invalid transition: ${from} \u2192 ${to}`);
+      return false;
+    }
+    this.store.setState({ status: to });
+    return true;
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Watch Time
+  // ═══════════════════════════════════════════
+  startWatchTime() {
+    if (this.watchTimeInterval) return;
+    this.watchTimeInterval = setInterval(() => {
+      this.store.setState((s) => ({ watchTime: s.watchTime + 1 }));
+    }, 1e3);
+  }
+  stopWatchTime() {
+    if (this.watchTimeInterval) {
+      clearInterval(this.watchTimeInterval);
+      this.watchTimeInterval = null;
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Circuit Breaker
+  // ═══════════════════════════════════════════
+  checkCircuit() {
+    if (this.circuit.state === "closed" /* CLOSED */) return true;
+    if (this.circuit.state === "half_open" /* HALF_OPEN */) return true;
+    const elapsed = Date.now() - (this.circuit.openedAt ?? 0);
+    if (elapsed >= this.config.circuitBreakerResetMs) {
+      this.circuit.state = "half_open" /* HALF_OPEN */;
+      this.logger?.info("[PlayerEngine] Circuit HALF_OPEN \u2014 trying recovery");
+      return true;
+    }
+    return false;
+  }
+  recordCircuitError(error) {
+    this.circuit.consecutiveErrors += 1;
+    this.circuit.lastError = error;
+    if (this.circuit.consecutiveErrors >= this.config.circuitBreakerThreshold) {
+      this.circuit.state = "open" /* OPEN */;
+      this.circuit.openedAt = Date.now();
+      this.logger?.warn(
+        `[PlayerEngine] Circuit OPEN after ${this.circuit.consecutiveErrors} errors`
+      );
+      if (this.circuitResetTimer) clearTimeout(this.circuitResetTimer);
+      this.circuitResetTimer = setTimeout(() => {
+        this.circuit.state = "half_open" /* HALF_OPEN */;
+        this.circuitResetTimer = null;
+      }, this.config.circuitBreakerResetMs);
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Analytics
+  // ═══════════════════════════════════════════
+  trackLeave(state) {
+    if (!this.analytics || !state.currentVideoId) return;
+    if (state.watchTime > 0) {
+      this.analytics.trackView(state.currentVideoId, state.watchTime);
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Events
+  // ═══════════════════════════════════════════
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+function createInitialState2() {
+  return {
+    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 = {}, logger) {
+    this.dataSource = dataSource;
+    /** Cancel in-flight requests */
+    this.abortController = null;
+    /** In-flight request deduplication: cursor → Promise */
+    this.inFlightRequests = /* @__PURE__ */ new Map();
+    /** LRU tracking: itemId → lastAccessTime */
+    this.accessOrder = /* @__PURE__ */ new Map();
+    /** Prefetch cache — instance-scoped (not static) */
+    this.prefetchCache = null;
+    this.config = { ...DEFAULT_FEED_CONFIG, ...config };
+    this.logger = logger;
+    this.store = vanilla.createStore(createInitialState2);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Data Source
+  // ═══════════════════════════════════════════
+  getDataSource() {
+    return this.dataSource;
+  }
+  setDataSource(dataSource, reset = true) {
+    this.dataSource = dataSource;
+    this.abortController?.abort();
+    this.abortController = null;
+    this.inFlightRequests.clear();
+    if (reset) {
+      this.store.setState(createInitialState2());
+      this.accessOrder.clear();
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Prefetch
+  // ═══════════════════════════════════════════
+  async prefetch(ttlMs) {
+    if (this.prefetchCache) {
+      const ttl = ttlMs ?? this.config.staleTTL;
+      if (Date.now() - this.prefetchCache.timestamp < ttl) return;
+    }
+    try {
+      const page = await this.dataSource.fetchFeed(null);
+      this.prefetchCache = {
+        items: page.items,
+        nextCursor: page.nextCursor,
+        timestamp: Date.now()
+      };
+    } catch {
+    }
+  }
+  hasPrefetchCache() {
+    return this.prefetchCache !== null;
+  }
+  clearPrefetchCache() {
+    this.prefetchCache = null;
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Loading
+  // ═══════════════════════════════════════════
+  async loadInitial() {
+    const state = this.store.getState();
+    if (state.itemsById.size > 0 && state.lastFetchTime) {
+      const isStale = Date.now() - state.lastFetchTime > this.config.staleTTL;
+      if (!isStale) return;
+      this.store.setState({ isStale: true });
+    }
+    if (this.prefetchCache) {
+      const { items, nextCursor } = this.prefetchCache;
+      this.prefetchCache = null;
+      this.applyItems(items, nextCursor, false);
+      this.store.setState({ loading: false, lastFetchTime: Date.now(), isStale: false });
+      return;
+    }
+    await this.fetchPage(null, false);
+  }
+  async loadMore() {
+    const { loadingMore, hasMore, cursor, loading } = this.store.getState();
+    if (loadingMore || loading || !hasMore) return;
+    await this.fetchPage(cursor, true);
+  }
+  async refresh() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.store.setState({
+      ...createInitialState2(),
+      // Preserve existing items while loading to avoid blank screen
+      itemsById: this.store.getState().itemsById,
+      displayOrder: this.store.getState().displayOrder,
+      isStale: true
+    });
+    await this.fetchPage(null, false);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Items
+  // ═══════════════════════════════════════════
+  getItems() {
+    const { itemsById, displayOrder } = this.store.getState();
+    return displayOrder.map((id) => itemsById.get(id)).filter((item) => item !== void 0);
+  }
+  getItemById(id) {
+    this.accessOrder.set(id, Date.now());
+    return this.store.getState().itemsById.get(id);
+  }
+  updateItem(id, patch) {
+    const { itemsById } = this.store.getState();
+    const item = itemsById.get(id);
+    if (!item) return;
+    const updated = new Map(itemsById);
+    updated.set(id, { ...item, ...patch });
+    this.store.setState({ itemsById: updated });
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Lifecycle
+  // ═══════════════════════════════════════════
+  destroy() {
+    this.abortController?.abort();
+    this.inFlightRequests.clear();
+    this.accessOrder.clear();
+    this.prefetchCache = null;
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Fetch
+  // ═══════════════════════════════════════════
+  async fetchPage(cursor, isPagination) {
+    const cacheKey = cursor ?? "__initial__";
+    const inFlight = this.inFlightRequests.get(cacheKey);
+    if (inFlight) return inFlight;
+    const promise = this.doFetch(cursor, isPagination);
+    this.inFlightRequests.set(cacheKey, promise);
+    try {
+      await promise;
+    } finally {
+      this.inFlightRequests.delete(cacheKey);
+    }
+  }
+  async doFetch(cursor, isPagination) {
+    this.abortController?.abort();
+    const controller = new AbortController();
+    this.abortController = controller;
+    this.store.setState(
+      isPagination ? { loadingMore: true, error: null } : { loading: true, error: null }
+    );
+    let attempt = 0;
+    while (attempt <= this.config.maxRetries) {
+      if (controller.signal.aborted) return;
+      try {
+        const page = await this.dataSource.fetchFeed(cursor);
+        if (controller.signal.aborted) return;
+        this.applyItems(page.items, page.nextCursor, isPagination);
+        this.store.setState({
+          loading: false,
+          loadingMore: false,
+          hasMore: page.hasMore,
+          cursor: page.nextCursor,
+          lastFetchTime: Date.now(),
+          isStale: false,
+          error: null
+        });
+        return;
+      } catch (err) {
+        if (controller.signal.aborted) return;
+        attempt += 1;
+        if (attempt > this.config.maxRetries) {
+          const error = {
+            message: err instanceof Error ? err.message : "Unknown error",
+            code: "FETCH_FAILED",
+            retryable: true
+          };
+          this.store.setState({ loading: false, loadingMore: false, error });
+          this.logger?.error("[FeedManager] Fetch failed after retries", err);
+          return;
+        }
+        const delay = this.config.retryDelay * 2 ** (attempt - 1);
+        this.logger?.warn(`[FeedManager] Retrying in ${delay}ms (attempt ${attempt})`);
+        await sleep(delay);
+      }
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — State Mutation
+  // ═══════════════════════════════════════════
+  applyItems(incoming, _nextCursor, append) {
+    const { itemsById, displayOrder } = this.store.getState();
+    const nextById = new Map(itemsById);
+    const existingIds = new Set(displayOrder);
+    const newIds = [];
+    for (const item of incoming) {
+      if (!existingIds.has(item.id)) {
+        newIds.push(item.id);
+      }
+      nextById.set(item.id, item);
+      this.accessOrder.set(item.id, Date.now());
+    }
+    const nextOrder = append ? [...displayOrder, ...newIds] : newIds;
+    if (nextById.size > this.config.maxCacheSize) {
+      this.evictLRU(nextById, nextOrder);
+    }
+    this.store.setState({ itemsById: nextById, displayOrder: nextOrder });
+  }
+  evictLRU(itemsById, displayOrder) {
+    const evictCount = itemsById.size - this.config.maxCacheSize;
+    if (evictCount <= 0) return;
+    const sorted = [...this.accessOrder.entries()].sort(([, a], [, b]) => a - b);
+    let evicted = 0;
+    for (const [id] of sorted) {
+      if (evicted >= evictCount) break;
+      itemsById.delete(id);
+      this.accessOrder.delete(id);
+      const idx = displayOrder.indexOf(id);
+      if (idx !== -1) displayOrder.splice(idx, 1);
+      evicted++;
+    }
+    this.logger?.debug(`[FeedManager] Evicted ${evicted} LRU items`);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createInitialState3() {
+  return {
+    pendingActions: /* @__PURE__ */ new Map(),
+    failedQueue: [],
+    hasPending: false,
+    isRetrying: false,
+    likeDeltas: /* @__PURE__ */ new Map(),
+    followState: /* @__PURE__ */ new Map()
+  };
+}
+var OptimisticManager = class {
+  constructor(interaction, logger) {
+    /** Debounce timers: contentId → timer */
+    this.likeDebounceTimers = /* @__PURE__ */ new Map();
+    /** Pending like direction: contentId → final intended state */
+    this.pendingLikeState = /* @__PURE__ */ new Map();
+    this.interaction = interaction;
+    this.logger = logger;
+    this.store = vanilla.createStore(createInitialState3);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Like (debounced toggle)
+  // ═══════════════════════════════════════════
+  /**
+   * Debounced like toggle — prevents rapid API spam on double-tap.
+   * UI updates instantly; API call fires after 600ms debounce.
+   */
+  toggleLike(contentId, currentIsLiked) {
+    const pendingState = this.pendingLikeState.get(contentId) ?? currentIsLiked;
+    const nextLiked = !pendingState;
+    this.pendingLikeState.set(contentId, nextLiked);
+    this.store.setState((s) => {
+      const nextDeltas = new Map(s.likeDeltas);
+      nextDeltas.get(contentId) ?? 0;
+      const delta = (nextLiked ? 1 : 0) - (currentIsLiked ? 1 : 0);
+      nextDeltas.set(contentId, delta);
+      return { likeDeltas: nextDeltas };
+    });
+    const existing = this.likeDebounceTimers.get(contentId);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(async () => {
+      this.likeDebounceTimers.delete(contentId);
+      const finalState = this.pendingLikeState.get(contentId) ?? currentIsLiked;
+      this.pendingLikeState.delete(contentId);
+      try {
+        if (finalState) {
+          await this.interaction.like?.(contentId);
+        } else {
+          await this.interaction.unlike?.(contentId);
+        }
+        this.store.setState((s) => {
+          const nextDeltas = new Map(s.likeDeltas);
+          nextDeltas.delete(contentId);
+          return { likeDeltas: nextDeltas };
+        });
+      } catch (err) {
+        this.store.setState((s) => {
+          const nextDeltas = new Map(s.likeDeltas);
+          nextDeltas.delete(contentId);
+          return { likeDeltas: nextDeltas };
+        });
+        this.logger?.error("[OptimisticManager] toggleLike failed \u2014 rolled back", err);
+      }
+    }, 600);
+    this.likeDebounceTimers.set(contentId, timer);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Follow
+  // ═══════════════════════════════════════════
+  async toggleFollow(authorId, currentIsFollowing) {
+    const nextFollowing = !currentIsFollowing;
+    this.store.setState((s) => {
+      const next = new Map(s.followState);
+      next.set(authorId, nextFollowing);
+      return { followState: next };
+    });
+    try {
+      if (nextFollowing) {
+        await this.interaction.follow?.(authorId);
+      } else {
+        await this.interaction.unfollow?.(authorId);
+      }
+      return true;
+    } catch (err) {
+      this.store.setState((s) => {
+        const next = new Map(s.followState);
+        next.delete(authorId);
+        return { followState: next };
+      });
+      this.logger?.error("[OptimisticManager] toggleFollow failed \u2014 rolled back", err);
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Helpers
+  // ═══════════════════════════════════════════
+  getLikeDelta(contentId) {
+    return this.store.getState().likeDeltas.get(contentId) ?? 0;
+  }
+  getFollowState(authorId) {
+    return this.store.getState().followState.get(authorId);
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Lifecycle
+  // ═══════════════════════════════════════════
+  destroy() {
+    for (const timer of this.likeDebounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.likeDebounceTimers.clear();
+    this.pendingLikeState.clear();
+  }
+};
+var DEFAULT_RESOURCE_CONFIG = {
+  maxAllocations: 11,
+  bufferWindow: 3,
+  warmWindow: 4,
+  // 0ms debounce — setFocusedIndexImmediate is already used post-snap.
+  focusDebounceMs: 0,
+  preloadLookAhead: 3
+};
+var ResourceGovernor = class {
+  constructor(config = {}, videoLoader, network, logger) {
+    this.focusDebounceTimer = null;
+    this.config = { ...DEFAULT_RESOURCE_CONFIG, ...config };
+    this.videoLoader = videoLoader;
+    this.network = network;
+    this.logger = logger;
+    this.store = vanilla.createStore(() => ({
+      activeAllocations: /* @__PURE__ */ new Set(),
+      warmAllocations: /* @__PURE__ */ new Set(),
+      preloadQueue: [],
+      focusedIndex: 0,
+      totalItems: 0,
+      networkType: network?.getNetworkType() ?? "unknown",
+      isActive: false,
+      prefetchIndex: null
+    }));
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Lifecycle
+  // ═══════════════════════════════════════════
+  async activate() {
+    if (this.store.getState().isActive) return;
+    if (this.network) {
+      this.networkUnsubscribe = this.network.onNetworkChange((type) => {
+        this.store.setState({ networkType: type });
+      });
+    }
+    this.store.setState({ isActive: true });
+    this.recalculate();
+    this.logger?.debug("[ResourceGovernor] Activated");
+  }
+  deactivate() {
+    this.networkUnsubscribe?.();
+    if (this.focusDebounceTimer) clearTimeout(this.focusDebounceTimer);
+    this.store.setState({ isActive: false });
+  }
+  destroy() {
+    this.deactivate();
+    this.videoLoader?.clearAll();
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Feed State
+  // ═══════════════════════════════════════════
+  setTotalItems(count) {
+    this.store.setState({ totalItems: count });
+    this.recalculate();
+  }
+  /**
+   * Debounced focus update — prevents rapid re-allocations during fast swipe
+   */
+  setFocusedIndex(index) {
+    if (this.focusDebounceTimer) clearTimeout(this.focusDebounceTimer);
+    this.focusDebounceTimer = setTimeout(() => {
+      this.focusDebounceTimer = null;
+      this.setFocusedIndexImmediate(index);
+    }, this.config.focusDebounceMs);
+  }
+  setFocusedIndexImmediate(index) {
+    this.store.setState({ focusedIndex: index, prefetchIndex: null });
+    this.recalculate();
+  }
+  /**
+   * Signal that the given index should have its video src eagerly loaded.
+   * Called by the gesture layer at ~50% drag.  Pass null to clear.
+   */
+  setPrefetchIndex(index) {
+    this.store.setState({ prefetchIndex: index });
+  }
+  // ═══════════════════════════════════════════
+  // PUBLIC API — Allocation Queries
+  // ═══════════════════════════════════════════
+  isAllocated(index) {
+    return this.store.getState().activeAllocations.has(index);
+  }
+  isWarmAllocated(index) {
+    return this.store.getState().warmAllocations.has(index);
+  }
+  shouldRenderVideo(index) {
+    const state = this.store.getState();
+    return state.activeAllocations.has(index) || state.warmAllocations.has(index);
+  }
+  isPreloading(index) {
+    return this.store.getState().preloadQueue.includes(index);
+  }
+  getActiveAllocations() {
+    return [...this.store.getState().activeAllocations];
+  }
+  getWarmAllocations() {
+    return [...this.store.getState().warmAllocations];
+  }
+  // ═══════════════════════════════════════════
+  // PRIVATE — Allocation Logic (3-Tier)
+  // ═══════════════════════════════════════════
+  recalculate() {
+    const { focusedIndex, totalItems, isActive } = this.store.getState();
+    if (!isActive || totalItems === 0) return;
+    const { maxAllocations, bufferWindow, warmWindow, preloadLookAhead } = this.config;
+    const hotDesired = [];
+    hotDesired.push(focusedIndex);
+    for (let delta = 1; delta <= bufferWindow; delta++) {
+      const ahead = focusedIndex + delta;
+      const behind = focusedIndex - delta;
+      if (ahead < totalItems) hotDesired.push(ahead);
+      if (behind >= 0) hotDesired.push(behind);
+    }
+    const warmDesired = [];
+    const hotEnd = Math.min(totalItems - 1, focusedIndex + bufferWindow);
+    const hotStart = Math.max(0, focusedIndex - bufferWindow);
+    const forwardWarmCount = Math.max(0, warmWindow - 1);
+    for (let i = 1; i <= forwardWarmCount; i++) {
+      const idx = hotEnd + i;
+      if (idx < totalItems) warmDesired.push(idx);
+    }
+    const backwardIdx = hotStart - 1;
+    if (backwardIdx >= 0) warmDesired.push(backwardIdx);
+    const totalDesired = hotDesired.length + warmDesired.length;
+    let finalHot = hotDesired;
+    let finalWarm = warmDesired;
+    if (totalDesired > maxAllocations) {
+      const warmBudget = Math.max(0, maxAllocations - hotDesired.length);
+      finalWarm = warmDesired.slice(0, warmBudget);
+      if (hotDesired.length > maxAllocations) {
+        finalHot = hotDesired.slice(0, maxAllocations);
+        finalWarm = [];
+      }
+    }
+    const newActiveAllocations = new Set(finalHot);
+    const newWarmAllocations = new Set(finalWarm);
+    const warmEnd = finalWarm.length > 0 ? Math.max(...finalWarm.filter((i) => i > focusedIndex), hotEnd) : hotEnd;
+    const preloadStart = warmEnd + 1;
+    const preloadEnd = Math.min(totalItems - 1, preloadStart + preloadLookAhead - 1);
+    const preloadQueue = [];
+    for (let i = preloadStart; i <= preloadEnd; i++) {
+      preloadQueue.push(i);
+    }
+    this.store.setState({
+      activeAllocations: newActiveAllocations,
+      warmAllocations: newWarmAllocations,
+      preloadQueue
+    });
+    this.logger?.debug(
+      `[ResourceGovernor] Hot: [${finalHot}], Warm: [${finalWarm}], Preload: [${preloadQueue}]`
+    );
+  }
+};
+function usePointerGesture(config = {}) {
+  const {
+    axis = "y",
+    velocityThreshold = 0.3,
+    distanceThreshold = 80,
+    disabled = false,
+    onDragOffset,
+    onDragThreshold,
+    containerSize,
+    dragThresholdRatio = 0.5,
+    onSnap,
+    onBounceBack
+  } = config;
+  const isDraggingRef = react.useRef(false);
+  const dragOffsetRef = react.useRef(0);
+  const startPointRef = react.useRef(0);
+  const startTimeRef = react.useRef(0);
+  const lastPointRef = react.useRef(0);
+  const lastTimeRef = react.useRef(0);
+  const velocityRef = react.useRef(0);
+  const rafIdRef = react.useRef(null);
+  const isLockedRef = react.useRef(false);
+  const startCrossAxisRef = react.useRef(0);
+  const thresholdFiredRef = react.useRef(false);
+  const onDragOffsetRef = react.useRef(onDragOffset);
+  const onDragThresholdRef = react.useRef(onDragThreshold);
+  const onSnapRef = react.useRef(onSnap);
+  const onBounceBackRef = react.useRef(onBounceBack);
+  const disabledRef = react.useRef(disabled);
+  const containerSizeRef = react.useRef(containerSize);
+  const dragThresholdRatioRef = react.useRef(dragThresholdRatio);
+  react.useEffect(() => {
+    onDragOffsetRef.current = onDragOffset;
+    onDragThresholdRef.current = onDragThreshold;
+    onSnapRef.current = onSnap;
+    onBounceBackRef.current = onBounceBack;
+    disabledRef.current = disabled;
+    containerSizeRef.current = containerSize;
+    dragThresholdRatioRef.current = dragThresholdRatio;
+  });
+  const scheduleFrame = react.useCallback(
+    (offset) => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+      }
+      rafIdRef.current = requestAnimationFrame(() => {
+        rafIdRef.current = null;
+        onDragOffsetRef.current?.(offset);
+      });
+    },
+    []
+  );
+  const cancelPendingFrame = react.useCallback(() => {
+    if (rafIdRef.current !== null) {
+      cancelAnimationFrame(rafIdRef.current);
+      rafIdRef.current = null;
+    }
+  }, []);
+  const handlePointerMove = react.useCallback(
+    (e) => {
+      if (!isDraggingRef.current || isLockedRef.current) return;
+      const mainPos = axis === "y" ? e.clientY : e.clientX;
+      const crossPos = axis === "y" ? e.clientX : e.clientY;
+      const now = performance.now();
+      const mainDelta = mainPos - startPointRef.current;
+      const crossDelta = Math.abs(crossPos - startCrossAxisRef.current);
+      if (Math.abs(mainDelta) < 20 && crossDelta > Math.abs(mainDelta) * 1.5) {
+        isLockedRef.current = true;
+        cancelPendingFrame();
+        onDragOffsetRef.current?.(0);
+        return;
+      }
+      const dt = now - lastTimeRef.current;
+      if (dt > 0) {
+        const instantVelocity = (mainPos - lastPointRef.current) / dt;
+        velocityRef.current = velocityRef.current * 0.7 + instantVelocity * 0.3;
+      }
+      lastPointRef.current = mainPos;
+      lastTimeRef.current = now;
+      const offset = mainPos - startPointRef.current;
+      dragOffsetRef.current = offset;
+      if (!thresholdFiredRef.current && onDragThresholdRef.current) {
+        const size = containerSizeRef.current ?? (axis === "y" ? window.innerHeight : window.innerWidth);
+        const threshold = size * dragThresholdRatioRef.current;
+        if (Math.abs(offset) >= threshold) {
+          thresholdFiredRef.current = true;
+          const direction = offset < 0 ? "forward" : "backward";
+          onDragThresholdRef.current(direction);
+        }
+      }
+      scheduleFrame(offset);
+    },
+    [axis, scheduleFrame, cancelPendingFrame]
+  );
+  const handlePointerUp = react.useCallback(
+    (_e) => {
+      if (!isDraggingRef.current) return;
+      cancelPendingFrame();
+      isDraggingRef.current = false;
+      window.removeEventListener("pointermove", handlePointerMove);
+      window.removeEventListener("pointerup", handlePointerUp);
+      window.removeEventListener("pointercancel", handlePointerUp);
+      const offset = dragOffsetRef.current;
+      const velocity = velocityRef.current;
+      const shouldSnap = Math.abs(velocity) > velocityThreshold || Math.abs(offset) > distanceThreshold;
+      if (shouldSnap) {
+        const direction = offset < 0 || velocity < 0 ? "forward" : "backward";
+        onSnapRef.current?.(direction);
+      } else {
+        onBounceBackRef.current?.();
+      }
+      dragOffsetRef.current = 0;
+      velocityRef.current = 0;
+    },
+    [handlePointerMove, velocityThreshold, distanceThreshold, cancelPendingFrame]
+  );
+  const onPointerDown = react.useCallback(
+    (e) => {
+      if (disabledRef.current) return;
+      if (!e.isPrimary) return;
+      if (e.button !== 0) return;
+      const mainPos = axis === "y" ? e.clientY : e.clientX;
+      const crossPos = axis === "y" ? e.clientX : e.clientY;
+      isDraggingRef.current = true;
+      isLockedRef.current = false;
+      thresholdFiredRef.current = false;
+      startPointRef.current = mainPos;
+      startCrossAxisRef.current = crossPos;
+      startTimeRef.current = performance.now();
+      lastPointRef.current = mainPos;
+      lastTimeRef.current = performance.now();
+      velocityRef.current = 0;
+      dragOffsetRef.current = 0;
+      e.currentTarget.setPointerCapture(e.pointerId);
+      window.addEventListener("pointermove", handlePointerMove, { passive: true });
+      window.addEventListener("pointerup", handlePointerUp);
+      window.addEventListener("pointercancel", handlePointerUp);
+    },
+    [axis, handlePointerMove, handlePointerUp]
+  );
+  react.useEffect(() => {
+    return () => {
+      cancelPendingFrame();
+      window.removeEventListener("pointermove", handlePointerMove);
+      window.removeEventListener("pointerup", handlePointerUp);
+      window.removeEventListener("pointercancel", handlePointerUp);
+    };
+  }, [cancelPendingFrame, handlePointerMove, handlePointerUp]);
+  return {
+    bind: { onPointerDown },
+    isDraggingRef,
+    dragOffsetRef
+  };
+}
+function useSnapAnimation(config = {}) {
+  const { duration = 280, easing = "cubic-bezier(0.25, 0.46, 0.45, 0.94)" } = config;
+  const activeAnimations = react.useRef([]);
+  const cancelAnimation = react.useCallback(() => {
+    for (const anim of activeAnimations.current) {
+      anim.cancel();
+    }
+    activeAnimations.current = [];
+  }, []);
+  const runAnimation = react.useCallback(
+    (targets, animDuration) => {
+      cancelAnimation();
+      const animations = [];
+      for (const { element, fromY, toY } of targets) {
+        element.style.transition = "";
+        const anim = element.animate(
+          [
+            { transform: `translateY(${fromY}px)` },
+            { transform: `translateY(${toY}px)` }
+          ],
+          {
+            duration: animDuration,
+            easing,
+            fill: "forwards"
+          }
+        );
+        anim.addEventListener("finish", () => {
+          element.style.transform = `translateY(${toY}px)`;
+          anim.cancel();
+        });
+        animations.push(anim);
+      }
+      activeAnimations.current = animations;
+    },
+    [duration, easing, cancelAnimation]
+  );
+  const animateSnap = react.useCallback(
+    (targets) => {
+      runAnimation(targets, duration);
+    },
+    [runAnimation, duration]
+  );
+  const animateBounceBack = react.useCallback(
+    (targets) => {
+      runAnimation(targets, Math.round(duration * 1.2));
+    },
+    [runAnimation, duration]
+  );
+  react.useEffect(() => {
+    return () => {
+      cancelAnimation();
+    };
+  }, [cancelAnimation]);
+  return { animateSnap, animateBounceBack, cancelAnimation };
+}
+var SDKContext = react.createContext(null);
+function ReelsProvider({ children, adapters, debug = false }) {
+  const logger = adapters.logger;
+  const sdkRef = react.useRef(null);
+  const value = react.useMemo(() => {
+    if (sdkRef.current) {
+      sdkRef.current.feedManager.destroy();
+      sdkRef.current.playerEngine.destroy();
+      sdkRef.current.resourceGovernor.destroy();
+      sdkRef.current.optimisticManager.destroy();
+    }
+    const feedManager = new FeedManager(adapters.dataSource, {}, logger);
+    const playerEngine = new PlayerEngine(
+      {},
+      adapters.analytics,
+      logger
+    );
+    const resourceGovernor = new ResourceGovernor(
+      {},
+      adapters.videoLoader,
+      adapters.network,
+      logger
+    );
+    const optimisticManager = new OptimisticManager(
+      adapters.interaction ?? {},
+      logger
+    );
+    const instance = {
+      feedManager,
+      playerEngine,
+      resourceGovernor,
+      optimisticManager,
+      adapters
+    };
+    sdkRef.current = instance;
+    return instance;
+  }, [adapters.dataSource]);
+  react.useEffect(() => {
+    value.resourceGovernor.activate();
+    return () => {
+      value.resourceGovernor.deactivate();
+    };
+  }, [value.resourceGovernor]);
+  react.useEffect(() => {
+    if (debug) {
+      logger?.debug("[ReelsProvider] Mounted in debug mode");
+    }
+  }, [debug, logger]);
+  react.useEffect(() => {
+    return () => {
+      sdkRef.current?.feedManager.destroy();
+      sdkRef.current?.playerEngine.destroy();
+      sdkRef.current?.resourceGovernor.destroy();
+      sdkRef.current?.optimisticManager.destroy();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(SDKContext.Provider, { value, children });
+}
+function useSDK() {
+  const ctx = react.useContext(SDKContext);
+  if (!ctx) {
+    throw new Error("[useSDK] Must be used inside <ReelsProvider>");
+  }
+  return ctx;
+}
+function useFeedSelector(selector) {
+  const { feedManager } = useSDK();
+  const selectorRef = react.useRef(selector);
+  selectorRef.current = selector;
+  const lastSnapshot = react.useRef(void 0);
+  const lastState = react.useRef(void 0);
+  const getSnapshot = react.useCallback(() => {
+    const state = feedManager.store.getState();
+    if (state !== lastState.current) {
+      lastState.current = state;
+      lastSnapshot.current = selectorRef.current(state);
+    }
+    return lastSnapshot.current;
+  }, [feedManager]);
+  return react.useSyncExternalStore(feedManager.store.subscribe, getSnapshot, getSnapshot);
+}
+function useFeed() {
+  const { feedManager } = useSDK();
+  const selectDisplayOrder = react.useCallback((s) => s.displayOrder, []);
+  const selectLoading = react.useCallback((s) => s.loading, []);
+  const selectLoadingMore = react.useCallback((s) => s.loadingMore, []);
+  const selectHasMore = react.useCallback((s) => s.hasMore, []);
+  const selectError = react.useCallback((s) => s.error, []);
+  const selectIsStale = react.useCallback((s) => s.isStale, []);
+  const selectItemsById = react.useCallback((s) => s.itemsById, []);
+  const displayOrder = useFeedSelector(selectDisplayOrder);
+  const itemsById = useFeedSelector(selectItemsById);
+  const loading = useFeedSelector(selectLoading);
+  const loadingMore = useFeedSelector(selectLoadingMore);
+  const hasMore = useFeedSelector(selectHasMore);
+  const error = useFeedSelector(selectError);
+  const isStale = useFeedSelector(selectIsStale);
+  const items = react.useMemo(
+    () => displayOrder.map((id) => itemsById.get(id)).filter((item) => item !== void 0),
+    [displayOrder, itemsById]
+  );
+  const loadInitial = react.useCallback(() => feedManager.loadInitial(), [feedManager]);
+  const loadMore = react.useCallback(() => feedManager.loadMore(), [feedManager]);
+  const refresh = react.useCallback(() => feedManager.refresh(), [feedManager]);
+  return {
+    items,
+    loading,
+    loadingMore,
+    hasMore,
+    error,
+    isStale,
+    loadInitial,
+    loadMore,
+    refresh
+  };
+}
+function useResourceSelector(selector) {
+  const { resourceGovernor } = useSDK();
+  const selectorRef = react.useRef(selector);
+  selectorRef.current = selector;
+  const lastSnapshot = react.useRef(void 0);
+  const lastState = react.useRef(void 0);
+  const getSnapshot = react.useCallback(() => {
+    const state = resourceGovernor.store.getState();
+    if (state !== lastState.current) {
+      lastState.current = state;
+      lastSnapshot.current = selectorRef.current(state);
+    }
+    return lastSnapshot.current;
+  }, [resourceGovernor]);
+  return react.useSyncExternalStore(resourceGovernor.store.subscribe, getSnapshot, getSnapshot);
+}
+function useResource() {
+  const { resourceGovernor } = useSDK();
+  const activeAllocations = useResourceSelector((s) => s.activeAllocations);
+  const warmAllocations = useResourceSelector((s) => s.warmAllocations);
+  const focusedIndex = useResourceSelector((s) => s.focusedIndex);
+  const totalItems = useResourceSelector((s) => s.totalItems);
+  const networkType = useResourceSelector((s) => s.networkType);
+  const isActive = useResourceSelector((s) => s.isActive);
+  const prefetchIndex = useResourceSelector((s) => s.prefetchIndex);
+  const activeIndices = react.useMemo(() => [...activeAllocations], [activeAllocations]);
+  const warmIndices = react.useMemo(() => [...warmAllocations], [warmAllocations]);
+  const setFocusedIndex = react.useCallback(
+    (i) => resourceGovernor.setFocusedIndex(i),
+    [resourceGovernor]
+  );
+  const setFocusedIndexImmediate = react.useCallback(
+    (i) => resourceGovernor.setFocusedIndexImmediate(i),
+    [resourceGovernor]
+  );
+  const setTotalItems = react.useCallback(
+    (n) => resourceGovernor.setTotalItems(n),
+    [resourceGovernor]
+  );
+  const shouldRenderVideo = react.useCallback(
+    (i) => resourceGovernor.shouldRenderVideo(i),
+    [resourceGovernor]
+  );
+  const isAllocated = react.useCallback(
+    (i) => resourceGovernor.isAllocated(i),
+    [resourceGovernor]
+  );
+  const isWarmAllocated = react.useCallback(
+    (i) => resourceGovernor.isWarmAllocated(i),
+    [resourceGovernor]
+  );
+  const setPrefetchIndex = react.useCallback(
+    (i) => resourceGovernor.setPrefetchIndex(i),
+    [resourceGovernor]
+  );
+  return {
+    activeIndices,
+    warmIndices,
+    focusedIndex,
+    totalItems,
+    networkType,
+    isActive,
+    prefetchIndex,
+    setFocusedIndex,
+    setFocusedIndexImmediate,
+    setTotalItems,
+    shouldRenderVideo,
+    isAllocated,
+    isWarmAllocated,
+    setPrefetchIndex
+  };
+}
+var ACTIVE_HLS_DEFAULTS = {
+  maxBufferLength: 10,
+  maxMaxBufferLength: 15,
+  capLevelToPlayerSize: true,
+  startLevel: 0,
+  abrEwmaDefaultEstimate: 5e5,
+  lowLatencyMode: false,
+  backBufferLength: 5,
+  enableWorker: true
+};
+var HOT_HLS_DEFAULTS = {
+  maxBufferLength: 2,
+  maxMaxBufferLength: 3,
+  capLevelToPlayerSize: true,
+  startLevel: 0,
+  abrEwmaDefaultEstimate: 5e5,
+  lowLatencyMode: false,
+  backBufferLength: 0,
+  enableWorker: true
+};
+var WARM_HLS_DEFAULTS = {
+  maxBufferLength: 0.5,
+  maxMaxBufferLength: 1,
+  capLevelToPlayerSize: true,
+  startLevel: 0,
+  abrEwmaDefaultEstimate: 5e5,
+  lowLatencyMode: false,
+  backBufferLength: 0,
+  enableWorker: true
+};
+function getHlsConfigForTier(tier) {
+  switch (tier) {
+    case "hot":
+      return HOT_HLS_DEFAULTS;
+    case "warm":
+      return WARM_HLS_DEFAULTS;
+    case "active":
+    default:
+      return ACTIVE_HLS_DEFAULTS;
+  }
+}
+function supportsNativeHls() {
+  if (typeof document === "undefined") return false;
+  const video = document.createElement("video");
+  return video.canPlayType("application/vnd.apple.mpegurl") !== "";
+}
+function mapHlsError(data) {
+  switch (data.type) {
+    case Hls__default.default.ErrorTypes.NETWORK_ERROR:
+      return {
+        code: "NETWORK_ERROR",
+        message: `HLS network error: ${data.details} \u2014 ${data.error?.message ?? "unknown"}`
+      };
+    case Hls__default.default.ErrorTypes.MEDIA_ERROR:
+      if (data.details === Hls__default.default.ErrorDetails.FRAG_PARSING_ERROR || data.details === Hls__default.default.ErrorDetails.BUFFER_APPEND_ERROR) {
+        return {
+          code: "DECODE_ERROR",
+          message: `HLS decode error: ${data.details}`
+        };
+      }
+      return {
+        code: "MEDIA_ERROR",
+        message: `HLS media error: ${data.details}`
+      };
+    default:
+      return {
+        code: "UNKNOWN",
+        message: `HLS error: ${data.type} / ${data.details}`
+      };
+  }
+}
+function useHls(options) {
+  const { src, videoRef, isActive, isPrefetch, bufferTier = "active", hlsConfig, onError } = options;
+  const isHlsSupported = typeof window !== "undefined" && Hls__default.default.isSupported();
+  const isNative = supportsNativeHls();
+  const isHlsJs = isHlsSupported && !isNative;
+  const [isReady, setIsReady] = react.useState(false);
+  const hlsRef = react.useRef(null);
+  const onErrorRef = react.useRef(onError);
+  const mediaRecoveryAttemptedRef = react.useRef(false);
+  const currentTierRef = react.useRef(bufferTier);
+  const canPlayFiredRef = react.useRef(false);
+  onErrorRef.current = onError;
+  const destroy = react.useCallback(() => {
+    if (hlsRef.current) {
+      hlsRef.current.destroy();
+      hlsRef.current = null;
+    }
+    canPlayFiredRef.current = false;
+  }, []);
+  const currentSrcRef = react.useRef(void 0);
+  react.useEffect(() => {
+    const video = videoRef.current;
+    if (!video || !src) {
+      destroy();
+      setIsReady(false);
+      canPlayFiredRef.current = false;
+      currentSrcRef.current = void 0;
+      return;
+    }
+    if (!isActive && !isPrefetch) {
+      destroy();
+      setIsReady(false);
+      canPlayFiredRef.current = false;
+      currentSrcRef.current = void 0;
+      return;
+    }
+    if (isNative) {
+      if (video.src !== src) {
+        video.src = src;
+      }
+      if (video.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
+        setIsReady(true);
+        currentSrcRef.current = src;
+        return;
+      }
+      setIsReady(false);
+      currentSrcRef.current = src;
+      const handleCanPlay2 = () => setIsReady(true);
+      video.addEventListener("canplay", handleCanPlay2, { once: true });
+      return () => {
+        video.removeEventListener("canplay", handleCanPlay2);
+      };
+    }
+    if (!isHlsSupported) {
+      onErrorRef.current?.("UNKNOWN", "HLS playback not supported in this browser");
+      return;
+    }
+    if (hlsRef.current && currentSrcRef.current === src) {
+      if (!canPlayFiredRef.current) {
+        const handleCanPlay2 = () => {
+          canPlayFiredRef.current = true;
+          setIsReady(true);
+        };
+        video.addEventListener("canplay", handleCanPlay2, { once: true });
+        return () => {
+          video.removeEventListener("canplay", handleCanPlay2);
+        };
+      }
+      return void 0;
+    }
+    if (hlsRef.current) {
+      hlsRef.current.destroy();
+      hlsRef.current = null;
+    }
+    setIsReady(false);
+    canPlayFiredRef.current = false;
+    mediaRecoveryAttemptedRef.current = false;
+    currentSrcRef.current = src;
+    const initialTier = bufferTier;
+    currentTierRef.current = initialTier;
+    const tierDefaults = getHlsConfigForTier(initialTier);
+    const config = { ...tierDefaults };
+    if (hlsConfig) {
+      const keys = Object.keys(hlsConfig);
+      for (const key of keys) {
+        config[key] = hlsConfig[key];
+      }
+    }
+    const hls = new Hls__default.default(config);
+    hlsRef.current = hls;
+    hls.on(Hls__default.default.Events.ERROR, (_event, data) => {
+      if (!data.fatal) {
+        return;
+      }
+      if (data.type === Hls__default.default.ErrorTypes.MEDIA_ERROR && !mediaRecoveryAttemptedRef.current) {
+        mediaRecoveryAttemptedRef.current = true;
+        hls.recoverMediaError();
+        return;
+      }
+      const mapped = mapHlsError(data);
+      onErrorRef.current?.(mapped.code, mapped.message);
+    });
+    const handleCanPlay = () => {
+      canPlayFiredRef.current = true;
+      setIsReady(true);
+    };
+    video.addEventListener("canplay", handleCanPlay, { once: true });
+    hls.attachMedia(video);
+    hls.loadSource(src);
+    return () => {
+      video.removeEventListener("canplay", handleCanPlay);
+      if (hlsRef.current === hls) {
+        hls.destroy();
+        hlsRef.current = null;
+        canPlayFiredRef.current = false;
+        currentSrcRef.current = void 0;
+      }
+    };
+  }, [src, isActive, isPrefetch]);
+  react.useEffect(() => {
+    const hls = hlsRef.current;
+    if (!hls) {
+      currentTierRef.current = bufferTier;
+      return;
+    }
+    const prevTier = currentTierRef.current;
+    if (prevTier === bufferTier) return;
+    currentTierRef.current = bufferTier;
+    const newConfig = getHlsConfigForTier(bufferTier);
+    const hlsAnyConfig = hls.config;
+    const configKeys = Object.keys(newConfig);
+    for (const key of configKeys) {
+      hlsAnyConfig[key] = newConfig[key];
+    }
+  }, [bufferTier]);
+  return {
+    isHlsJs,
+    isReady,
+    destroy
+  };
+}
+function DefaultOverlay({ item }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { fontWeight: 700, fontSize: 15, marginBottom: 4 }, children: [
+      "@",
+      item.author.name
+    ] }),
+    item.title && /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 13, color: "#ddd", lineHeight: 1.4 }, children: item.title })
+  ] });
+}
+function DefaultActions({ item, actions }) {
+  const likes = item.stats.likes + actions.likeDelta;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ActionBtn, { icon: "\u2764\uFE0F", count: formatCount(likes) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ActionBtn, { icon: "\u{1F4AC}", count: formatCount(item.stats.comments) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ActionBtn, { icon: "\u2197\uFE0F", count: "Share" })
+  ] });
+}
+function ActionBtn({ icon, count }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { textAlign: "center", cursor: "pointer" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 28 }, children: icon }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 11, color: "#fff", marginTop: 2 }, children: count })
+  ] });
+}
+function formatCount(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function DefaultSkeleton() {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100dvh",
+        background: "#111",
+        position: "relative",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              inset: 0,
+              background: "linear-gradient(90deg, transparent 0%, rgba(255,255,255,0.04) 50%, transparent 100%)",
+              animation: "reels-sdk-shimmer 1.5s ease-in-out infinite"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              bottom: 100,
+              left: 16,
+              display: "flex",
+              flexDirection: "column",
+              gap: 8
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonBar(120, 14) }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonBar(200, 12) }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonBar(160, 12) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              bottom: 100,
+              right: 16,
+              display: "flex",
+              flexDirection: "column",
+              gap: 20,
+              alignItems: "center"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonCircle(40) }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonCircle(40) }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: skeletonCircle(40) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+        @keyframes reels-sdk-shimmer {
+          0% { transform: translateX(-100%); }
+          100% { transform: translateX(100%); }
+        }
+      ` })
+      ]
+    }
+  );
+}
+function skeletonBar(width, height) {
+  return {
+    width,
+    height,
+    borderRadius: height / 2,
+    background: "rgba(255,255,255,0.1)"
+  };
+}
+function skeletonCircle(size) {
+  return {
+    width: size,
+    height: size,
+    borderRadius: "50%",
+    background: "rgba(255,255,255,0.1)"
+  };
+}
+function VideoSlot({
+  item,
+  index,
+  isActive,
+  isPrefetch,
+  isPreloaded,
+  bufferTier,
+  isMuted,
+  onToggleMute,
+  showFps = false,
+  renderOverlay,
+  renderActions
+}) {
+  const { optimisticManager, adapters } = useSDK();
+  if (!isVideoItem(item)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "relative",
+          width: "100%",
+          height: "100%",
+          background: "#111",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          color: "#fff",
+          fontSize: 14
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Non-video content" })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    VideoSlotInner,
+    {
+      item,
+      index,
+      isActive,
+      isPrefetch,
+      isPreloaded,
+      bufferTier,
+      isMuted,
+      onToggleMute,
+      showFps,
+      renderOverlay,
+      renderActions,
+      optimisticManager,
+      adapters
+    }
+  );
+}
+function VideoSlotInner({
+  item,
+  index,
+  isActive,
+  isPrefetch,
+  isPreloaded,
+  bufferTier,
+  isMuted,
+  onToggleMute,
+  showFps,
+  renderOverlay,
+  renderActions,
+  optimisticManager,
+  adapters
+}) {
+  const videoRef = react.useRef(null);
+  const shouldLoadSrc = isActive || isPrefetch || isPreloaded;
+  const src = item.source.url;
+  const sourceType = item.source.type;
+  const isHlsSource = sourceType === "hls";
+  const hlsSrc = isHlsSource && shouldLoadSrc ? src : void 0;
+  const mp4Src = !isHlsSource && shouldLoadSrc ? src : void 0;
+  const { isReady: hlsReady } = useHls({
+    src: hlsSrc,
+    videoRef,
+    isActive,
+    // Pass true for isPrefetch when the slot is preloaded (hot/warm tier)
+    // so useHls creates the HLS instance and starts buffering
+    isPrefetch: isPrefetch || isPreloaded,
+    bufferTier,
+    onError: (code, message) => {
+      console.error(`[VideoSlot] HLS error: ${code} \u2014 ${message}`);
+    }
+  });
+  const [mp4Ready, setMp4Ready] = react.useState(false);
+  react.useEffect(() => {
+    if (isHlsSource) return;
+    const video = videoRef.current;
+    if (!video || !mp4Src) {
+      setMp4Ready(false);
+      return;
+    }
+    if (video.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
+      setMp4Ready(true);
+      return;
+    }
+    setMp4Ready(false);
+    const onCanPlay = () => setMp4Ready(true);
+    video.addEventListener("canplay", onCanPlay, { once: true });
+    return () => video.removeEventListener("canplay", onCanPlay);
+  }, [mp4Src, isHlsSource]);
+  react.useEffect(() => {
+    if (isHlsSource) return;
+    const video = videoRef.current;
+    if (!video || !mp4Src) return;
+    if (!isActive && (isPrefetch || isPreloaded)) {
+      video.load();
+    }
+  }, [mp4Src, isActive, isPrefetch, isPreloaded, isHlsSource]);
+  const isReady = isHlsSource ? hlsReady : mp4Ready;
+  const [hasPlayedAhead, setHasPlayedAhead] = react.useState(false);
+  react.useEffect(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    if (isActive || !isReady) return;
+    if (hasPlayedAhead) return;
+    const prevMuted = video.muted;
+    video.muted = true;
+    let cancelled = false;
+    const doPlayAhead = async () => {
+      try {
+        await video.play();
+        if (cancelled) return;
+        const pauseAfterDecode = () => {
+          if (cancelled) return;
+          video.pause();
+          video.currentTime = 0;
+          video.muted = prevMuted;
+          setHasPlayedAhead(true);
+        };
+        setTimeout(pauseAfterDecode, 50);
+      } catch {
+      }
+    };
+    doPlayAhead();
+    return () => {
+      cancelled = true;
+    };
+  }, [isActive, isReady, hasPlayedAhead]);
+  react.useEffect(() => {
+    setHasPlayedAhead(false);
+  }, [src]);
+  const wasActiveRef = react.useRef(false);
+  react.useEffect(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    let onReady = null;
+    if (isActive) {
+      wasActiveRef.current = true;
+      video.muted = isMuted;
+      if (video.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
+        video.play().catch(() => {
+        });
+      } else {
+        onReady = () => {
+          video.play().catch(() => {
+          });
+        };
+        video.addEventListener("canplay", onReady, { once: true });
+      }
+    } else if (wasActiveRef.current) {
+      video.pause();
+      video.currentTime = 0;
+      wasActiveRef.current = false;
+      setHasPlayedAhead(false);
+    } else if (!hasPlayedAhead) {
+      video.pause();
+    }
+    return () => {
+      if (onReady) video.removeEventListener("canplay", onReady);
+    };
+  }, [isActive, isMuted, hasPlayedAhead]);
+  react.useEffect(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    video.muted = isMuted;
+  }, [isMuted]);
+  const showPosterOverlay = !isReady && !hasPlayedAhead;
+  const [showMuteIndicator, setShowMuteIndicator] = react.useState(false);
+  const muteIndicatorTimer = react.useRef(null);
+  const handleTap = react.useCallback(() => {
+    onToggleMute();
+    setShowMuteIndicator(true);
+    if (muteIndicatorTimer.current) clearTimeout(muteIndicatorTimer.current);
+    muteIndicatorTimer.current = setTimeout(() => setShowMuteIndicator(false), 1200);
+  }, [onToggleMute]);
+  react.useEffect(() => {
+    return () => {
+      if (muteIndicatorTimer.current) clearTimeout(muteIndicatorTimer.current);
+    };
+  }, []);
+  const likeDelta = react.useSyncExternalStore(
+    optimisticManager.store.subscribe,
+    () => optimisticManager.getLikeDelta(item.id),
+    () => optimisticManager.getLikeDelta(item.id)
+  );
+  const followState = react.useSyncExternalStore(
+    optimisticManager.store.subscribe,
+    () => optimisticManager.getFollowState(item.author.id),
+    () => optimisticManager.getFollowState(item.author.id)
+  );
+  const actions = react.useMemo(() => ({
+    toggleLike: () => optimisticManager.toggleLike(item.id, item.interaction.isLiked),
+    likeDelta,
+    toggleFollow: () => optimisticManager.toggleFollow(item.author.id, item.interaction.isFollowing),
+    followState,
+    share: () => adapters.interaction?.share?.(item.id),
+    isMuted,
+    toggleMute: onToggleMute,
+    isActive,
+    index
+  }), [item, likeDelta, followState, isMuted, isActive, index, optimisticManager, adapters, onToggleMute]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        background: "#111",
+        overflow: "hidden"
+      },
+      onClick: handleTap,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "video",
+          {
+            ref: videoRef,
+            src: mp4Src,
+            loop: true,
+            muted: isMuted,
+            playsInline: true,
+            preload: shouldLoadSrc ? "auto" : "none",
+            style: {
+              width: "100%",
+              height: "100%",
+              objectFit: "cover",
+              // Hide video until ready to avoid black frame flash
+              opacity: showPosterOverlay ? 0 : 1,
+              transition: "opacity 0.15s ease"
+            }
+          }
+        ),
+        item.poster && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              inset: 0,
+              backgroundImage: `url(${item.poster})`,
+              backgroundSize: "cover",
+              backgroundPosition: "center",
+              opacity: showPosterOverlay ? 1 : 0,
+              transition: "opacity 0.15s ease",
+              pointerEvents: "none"
+            }
+          }
+        ),
+        showMuteIndicator && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: "50%",
+              left: "50%",
+              transform: "translate(-50%, -50%)",
+              background: "rgba(0,0,0,0.6)",
+              borderRadius: "50%",
+              width: 64,
+              height: 64,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              fontSize: 28,
+              pointerEvents: "none",
+              animation: "fadeInOut 1.2s ease forwards"
+            },
+            children: isMuted ? "\u{1F507}" : "\u{1F50A}"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              bottom: 80,
+              left: 16,
+              right: 80,
+              pointerEvents: "none",
+              color: "#fff"
+            },
+            children: renderOverlay ? renderOverlay(item, actions) : /* @__PURE__ */ jsxRuntime.jsx(DefaultOverlay, { item })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              bottom: 80,
+              right: 16,
+              display: "flex",
+              flexDirection: "column",
+              gap: 20,
+              alignItems: "center"
+            },
+            children: renderActions ? renderActions(item, actions) : /* @__PURE__ */ jsxRuntime.jsx(DefaultActions, { item, actions })
+          }
+        ),
+        showFps && /* @__PURE__ */ jsxRuntime.jsx(FpsCounter, {})
+      ]
+    }
+  );
+}
+function FpsCounter() {
+  const [fps, setFps] = react.useState(0);
+  const frameCountRef = react.useRef(0);
+  const lastTimeRef = react.useRef(performance.now());
+  react.useEffect(() => {
+    let rafId;
+    const tick = () => {
+      frameCountRef.current++;
+      const now = performance.now();
+      if (now - lastTimeRef.current >= 1e3) {
+        setFps(frameCountRef.current);
+        frameCountRef.current = 0;
+        lastTimeRef.current = now;
+      }
+      rafId = requestAnimationFrame(tick);
+    };
+    rafId = requestAnimationFrame(tick);
+    return () => cancelAnimationFrame(rafId);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        top: 12,
+        right: 12,
+        background: fps >= 55 ? "#00c853" : fps >= 30 ? "#ffd600" : "#d50000",
+        color: "#000",
+        fontSize: 11,
+        fontWeight: 700,
+        padding: "2px 6px",
+        borderRadius: 4,
+        fontFamily: "monospace"
+      },
+      children: [
+        fps,
+        "fps"
+      ]
+    }
+  );
+}
+var centerStyle = {
+  height: "100dvh",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  background: "#000",
+  color: "#fff"
+};
+function ReelsFeed({
+  renderOverlay,
+  renderActions,
+  renderLoading,
+  renderEmpty,
+  renderError: _renderError,
+  showFps = false,
+  loadMoreThreshold = 5,
+  onSlotChange,
+  gestureConfig,
+  snapConfig
+}) {
+  const { items, loading, loadInitial, loadMore, hasMore } = useFeed();
+  const {
+    focusedIndex,
+    prefetchIndex,
+    setFocusedIndexImmediate,
+    setTotalItems,
+    shouldRenderVideo,
+    isWarmAllocated,
+    setPrefetchIndex
+  } = useResource();
+  const [isMuted, setIsMuted] = react.useState(true);
+  const containerRef = react.useRef(null);
+  const slotCacheRef = react.useRef(/* @__PURE__ */ new Map());
+  const activeIndexRef = react.useRef(0);
+  activeIndexRef.current = focusedIndex;
+  const [isSnapping, setIsSnapping] = react.useState(false);
+  const { animateSnap, animateBounceBack, cancelAnimation } = useSnapAnimation({
+    duration: snapConfig?.duration ?? 260,
+    easing: snapConfig?.easing ?? "cubic-bezier(0.25, 0.46, 0.45, 0.94)"
+  });
+  react.useEffect(() => {
+    loadInitial();
+  }, [loadInitial]);
+  react.useEffect(() => {
+    setTotalItems(items.length);
+  }, [items.length, setTotalItems]);
+  react.useEffect(() => {
+    if (items.length - focusedIndex <= loadMoreThreshold && hasMore && !loading) {
+      loadMore();
+    }
+  }, [focusedIndex, items.length, hasMore, loading, loadMore, loadMoreThreshold]);
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const rebuild = () => {
+      slotCacheRef.current.clear();
+      const slots = container.querySelectorAll("[data-slot-index]");
+      for (const slot of slots) {
+        const idx = Number(slot.dataset.slotIndex);
+        slotCacheRef.current.set(idx, slot);
+      }
+    };
+    rebuild();
+    const observer = new MutationObserver(rebuild);
+    observer.observe(container, { childList: true, subtree: true });
+    return () => observer.disconnect();
+  }, [items.length]);
+  const containerHeight = react.useRef(
+    typeof window !== "undefined" ? window.innerHeight : 800
+  );
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    containerHeight.current = container.getBoundingClientRect().height || window.innerHeight;
+    const ro = new ResizeObserver(([entry]) => {
+      if (entry) {
+        containerHeight.current = entry.contentRect.height;
+        applyPositions(activeIndexRef.current, 0, false);
+      }
+    });
+    ro.observe(container);
+    return () => ro.disconnect();
+  }, []);
+  const applyPositions = react.useCallback((activeIdx, dragOffset = 0, _withTransition = false) => {
+    const h = containerHeight.current;
+    for (const [idx, slot] of slotCacheRef.current) {
+      const targetY = (idx - activeIdx) * h + dragOffset;
+      slot.style.transition = "none";
+      slot.style.transform = `translateY(${targetY}px)`;
+    }
+  }, []);
+  react.useEffect(() => {
+    applyPositions(focusedIndex, 0, false);
+  }, [focusedIndex, applyPositions]);
+  const handleDragThreshold = react.useCallback(
+    (direction) => {
+      const current = activeIndexRef.current;
+      const nextIdx = direction === "forward" ? Math.min(current + 1, items.length - 1) : Math.max(current - 1, 0);
+      if (nextIdx !== current) {
+        setPrefetchIndex(nextIdx);
+      }
+    },
+    [items.length, setPrefetchIndex]
+  );
+  const handleSnap = react.useCallback(
+    (direction) => {
+      const current = activeIndexRef.current;
+      const next = direction === "forward" ? Math.min(current + 1, items.length - 1) : Math.max(current - 1, 0);
+      if (next === current) {
+        const targets2 = [];
+        for (const [idx, el] of slotCacheRef.current) {
+          targets2.push({
+            element: el,
+            fromY: parsePxTranslateY(el),
+            toY: (idx - current) * containerHeight.current
+          });
+        }
+        animateBounceBack(targets2);
+        setPrefetchIndex(null);
+        return;
+      }
+      cancelAnimation();
+      setIsSnapping(true);
+      setPrefetchIndex(null);
+      setFocusedIndexImmediate(next);
+      const nextItem = items[next];
+      if (nextItem) {
+        onSlotChange?.(next, nextItem, current);
+      }
+      const h = containerHeight.current;
+      const targets = [];
+      for (const [idx, el] of slotCacheRef.current) {
+        targets.push({
+          element: el,
+          fromY: parsePxTranslateY(el),
+          toY: (idx - next) * h
+        });
+      }
+      animateSnap(targets);
+      setTimeout(() => setIsSnapping(false), 300);
+    },
+    [items, animateSnap, animateBounceBack, cancelAnimation, setFocusedIndexImmediate, setPrefetchIndex, onSlotChange]
+  );
+  const handleBounceBack = react.useCallback(() => {
+    const current = activeIndexRef.current;
+    const h = containerHeight.current;
+    const targets = [];
+    for (const [idx, el] of slotCacheRef.current) {
+      targets.push({
+        element: el,
+        fromY: parsePxTranslateY(el),
+        toY: (idx - current) * h
+      });
+    }
+    animateBounceBack(targets);
+    setPrefetchIndex(null);
+  }, [animateBounceBack, setPrefetchIndex]);
+  const { bind } = usePointerGesture({
+    axis: "y",
+    velocityThreshold: gestureConfig?.velocityThreshold ?? 0.3,
+    distanceThreshold: gestureConfig?.distanceThreshold ?? 80,
+    disabled: isSnapping,
+    containerSize: containerHeight.current,
+    dragThresholdRatio: gestureConfig?.dragThresholdRatio ?? 0.5,
+    onDragOffset: (offset) => {
+      applyPositions(activeIndexRef.current, offset, false);
+    },
+    onDragThreshold: handleDragThreshold,
+    onSnap: handleSnap,
+    onBounceBack: handleBounceBack
+  });
+  const getInitialTransformPx = react.useCallback(
+    (index) => {
+      const h = containerHeight.current;
+      return `translateY(${(index - focusedIndex) * h}px)`;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+    // Only for initial render; imperative system takes over after mount
+  );
+  const handleToggleMute = react.useCallback(() => {
+    setIsMuted((prev) => !prev);
+  }, []);
+  if (loading && items.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { style: { ...centerStyle, flexDirection: "column", gap: 0 }, children: renderLoading ? renderLoading() : /* @__PURE__ */ jsxRuntime.jsx(DefaultSkeleton, {}) });
+  }
+  if (!loading && items.length === 0) {
+    return renderEmpty ? renderEmpty() : /* @__PURE__ */ jsxRuntime.jsx("div", { style: centerStyle, children: "No videos found" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: containerRef,
+      ...bind,
+      style: {
+        position: "relative",
+        width: "100%",
+        height: "100dvh",
+        overflow: "hidden",
+        background: "#000",
+        touchAction: "none",
+        userSelect: "none"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+                @keyframes reels-sdk-fadeInOut {
+                    0% { opacity: 0; transform: translate(-50%, -50%) scale(0.8); }
+                    15% { opacity: 1; transform: translate(-50%, -50%) scale(1); }
+                    70% { opacity: 1; transform: translate(-50%, -50%) scale(1); }
+                    100% { opacity: 0; transform: translate(-50%, -50%) scale(0.8); }
+                }
+                @keyframes reels-sdk-spin {
+                    to { transform: rotate(360deg); }
+                }
+            ` }),
+        items.map((item, index) => {
+          const isActive = index === focusedIndex;
+          const isPrefetch = index === prefetchIndex;
+          const isWarm = isWarmAllocated(index);
+          const isVisible = shouldRenderVideo(index) || isPrefetch;
+          const bufferTier = isActive ? "active" : isWarm ? "warm" : "hot";
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              "data-slot-index": index,
+              style: {
+                position: "absolute",
+                inset: 0,
+                willChange: "transform",
+                transform: getInitialTransformPx(index)
+              },
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                VideoSlot,
+                {
+                  item,
+                  index,
+                  isActive,
+                  isPrefetch,
+                  isPreloaded: !isActive && !isPrefetch && isVisible,
+                  bufferTier,
+                  isMuted,
+                  onToggleMute: handleToggleMute,
+                  showFps: showFps && isActive,
+                  renderOverlay,
+                  renderActions
+                }
+              )
+            },
+            item.id
+          );
+        })
+      ]
+    }
+  );
+}
+function parsePxTranslateY(el) {
+  const transform = el.style.transform;
+  if (!transform) return 0;
+  const match = transform.match(/translateY\((-?[\d.]+)/);
+  if (!match || !match[1]) return 0;
+  return Number.parseFloat(match[1]);
+}
+function usePlayerSelector(selector) {
+  const { playerEngine } = useSDK();
+  const selectorRef = react.useRef(selector);
+  selectorRef.current = selector;
+  const lastSnapshot = react.useRef(void 0);
+  const lastState = react.useRef(void 0);
+  const getSnapshot = react.useCallback(() => {
+    const state = playerEngine.store.getState();
+    if (state !== lastState.current) {
+      lastState.current = state;
+      lastSnapshot.current = selectorRef.current(state);
+    }
+    return lastSnapshot.current;
+  }, [playerEngine]);
+  return react.useSyncExternalStore(playerEngine.store.subscribe, getSnapshot, getSnapshot);
+}
+function usePlayer() {
+  const { playerEngine } = useSDK();
+  const status = usePlayerSelector((s) => s.status);
+  const currentVideo = usePlayerSelector((s) => s.currentVideo);
+  const currentTime = usePlayerSelector((s) => s.currentTime);
+  const duration = usePlayerSelector((s) => s.duration);
+  const buffered = usePlayerSelector((s) => s.buffered);
+  const muted = usePlayerSelector((s) => s.muted);
+  const volume = usePlayerSelector((s) => s.volume);
+  const playbackRate = usePlayerSelector((s) => s.playbackRate);
+  const error = usePlayerSelector((s) => s.error);
+  const loopCount = usePlayerSelector((s) => s.loopCount);
+  const watchTime = usePlayerSelector((s) => s.watchTime);
+  const isPlaying = status === "playing" /* PLAYING */;
+  const isPaused = status === "paused" /* PAUSED */;
+  const isBuffering = status === "buffering" /* BUFFERING */;
+  const isLoading = status === "loading" /* LOADING */;
+  const hasError = status === "error" /* ERROR */;
+  const progress = duration > 0 ? currentTime / duration * 100 : 0;
+  const bufferProgress = duration > 0 ? buffered / duration * 100 : 0;
+  const play = react.useCallback(() => playerEngine.play(), [playerEngine]);
+  const pause = react.useCallback(() => playerEngine.pause(), [playerEngine]);
+  const togglePlay = react.useCallback(() => playerEngine.togglePlay(), [playerEngine]);
+  const seek = react.useCallback((t) => playerEngine.seek(t), [playerEngine]);
+  const setMuted = react.useCallback((m) => playerEngine.setMuted(m), [playerEngine]);
+  const toggleMute = react.useCallback(() => playerEngine.toggleMute(), [playerEngine]);
+  const setVolume = react.useCallback((v) => playerEngine.setVolume(v), [playerEngine]);
+  const setPlaybackRate = react.useCallback((r) => playerEngine.setPlaybackRate(r), [playerEngine]);
+  const handlers = {
+    onCanPlay: () => playerEngine.onCanPlay(),
+    onWaiting: () => playerEngine.onWaiting(),
+    onPlaying: () => playerEngine.onPlaying(),
+    onEnded: () => playerEngine.onEnded(),
+    onTimeUpdate: (e) => playerEngine.onTimeUpdate(e.currentTarget.currentTime),
+    onProgress: (e) => {
+      const video = e.currentTarget;
+      if (video.buffered.length > 0) {
+        playerEngine.onProgress(video.buffered.end(video.buffered.length - 1));
+      }
+    },
+    onLoadedMetadata: (e) => playerEngine.onLoadedMetadata(e.currentTarget.duration),
+    onError: () => playerEngine.onError("MEDIA_ERROR", "Video playback error")
+  };
+  return {
+    // State
+    status,
+    currentVideo,
+    currentTime,
+    duration,
+    buffered,
+    muted,
+    volume,
+    playbackRate,
+    error,
+    loopCount,
+    watchTime,
+    // Computed
+    isPlaying,
+    isPaused,
+    isBuffering,
+    isLoading,
+    hasError,
+    progress,
+    bufferProgress,
+    // Controls
+    play,
+    pause,
+    togglePlay,
+    seek,
+    setMuted,
+    toggleMute,
+    setVolume,
+    setPlaybackRate,
+    // Element handlers
+    handlers
+  };
+}
+
+// src/adapters/mock/index.ts
+var MockLogger = class {
+  constructor(prefix = "[MockLogger]") {
+    this.prefix = prefix;
+  }
+  debug(msg, ...args) {
+    console.debug(this.prefix, msg, ...args);
+  }
+  info(msg, ...args) {
+    console.info(this.prefix, msg, ...args);
+  }
+  warn(msg, ...args) {
+    console.warn(this.prefix, msg, ...args);
+  }
+  error(msg, ...args) {
+    console.error(this.prefix, msg, ...args);
+  }
+};
+var MockAnalytics = class {
+  constructor() {
+    this.events = [];
+  }
+  log(event, data) {
+    this.events.push({ event, data, ts: Date.now() });
+  }
+  trackView(videoId, duration) {
+    this.log("view", { videoId, duration });
+  }
+  trackLike(videoId, isLiked) {
+    this.log("like", { videoId, isLiked });
+  }
+  trackShare(videoId) {
+    this.log("share", { videoId });
+  }
+  trackComment(videoId) {
+    this.log("comment", { videoId });
+  }
+  trackError(videoId, error) {
+    this.log("error", { videoId, error });
+  }
+  trackPlaybackEvent(videoId, event, position) {
+    this.log("playback", { videoId, event, position });
+  }
+};
+var MockInteraction = class {
+  constructor(delayMs = 300) {
+    this.calls = [];
+    this.delay = delayMs;
+  }
+  async simulate(action) {
+    await new Promise((r) => setTimeout(r, this.delay));
+    this.calls.push(action);
+  }
+  async like(id) {
+    await this.simulate(`like:${id}`);
+  }
+  async unlike(id) {
+    await this.simulate(`unlike:${id}`);
+  }
+  async follow(id) {
+    await this.simulate(`follow:${id}`);
+  }
+  async unfollow(id) {
+    await this.simulate(`unfollow:${id}`);
+  }
+  async bookmark(id) {
+    await this.simulate(`bookmark:${id}`);
+  }
+  async unbookmark(id) {
+    await this.simulate(`unbookmark:${id}`);
+  }
+  async share(id) {
+    await this.simulate(`share:${id}`);
+  }
+};
+var MockSessionStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    return this.store.get(key) ?? null;
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  remove(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+var MockNetworkAdapter = class {
+  constructor() {
+    this.type = "wifi";
+    this.callbacks = [];
+  }
+  getNetworkType() {
+    return this.type;
+  }
+  isOnline() {
+    return this.type !== "offline";
+  }
+  onNetworkChange(cb) {
+    this.callbacks.push(cb);
+    return () => {
+      this.callbacks = this.callbacks.filter((c) => c !== cb);
+    };
+  }
+  /** Test helper: simulate network change */
+  simulateChange(type) {
+    this.type = type;
+    this.callbacks.forEach((cb) => cb(type));
+  }
+};
+var MockVideoLoader = class {
+  constructor(delayMs = 100) {
+    this.preloaded = /* @__PURE__ */ new Set();
+    this.loading = /* @__PURE__ */ new Set();
+    this.delayMs = delayMs;
+  }
+  async preload(videoId, _url, signal) {
+    this.loading.add(videoId);
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, this.delayMs);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(t);
+        reject(new Error("aborted"));
+      });
+    });
+    this.loading.delete(videoId);
+    this.preloaded.add(videoId);
+    return { videoId, status: "loaded", loadedBytes: 5e5 };
+  }
+  cancel(videoId) {
+    this.loading.delete(videoId);
+  }
+  isPreloaded(videoId) {
+    return this.preloaded.has(videoId);
+  }
+  getPreloadStatus(videoId) {
+    if (this.preloaded.has(videoId)) return "loaded";
+    if (this.loading.has(videoId)) return "loading";
+    return "idle";
+  }
+  clearAll() {
+    this.preloaded.clear();
+    this.loading.clear();
+  }
+};
+var MockDataSource = class {
+  constructor(options = {}) {
+    this.totalItems = options.totalItems ?? 20;
+    this.pageSize = options.pageSize ?? 5;
+    this.delayMs = options.delayMs ?? 500;
+  }
+  async fetchFeed(cursor) {
+    await new Promise((r) => setTimeout(r, this.delayMs));
+    const page = cursor ? Number.parseInt(cursor, 10) : 0;
+    const start = page * this.pageSize;
+    const end = Math.min(start + this.pageSize, this.totalItems);
+    const items = Array.from({ length: end - start }, (_, i) => {
+      const idx = start + i;
+      return {
+        id: `video-${idx}`,
+        type: "video",
+        source: {
+          url: `https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4`,
+          type: "mp4"
+        },
+        poster: `https://picsum.photos/seed/${idx}/400/700`,
+        duration: 30 + idx % 60,
+        title: `Video ${idx}`,
+        description: `Description for video ${idx} #shorts #viral`,
+        author: {
+          id: `author-${idx % 5}`,
+          name: `Creator ${idx % 5}`,
+          avatar: `https://picsum.photos/seed/author-${idx % 5}/100/100`,
+          isVerified: idx % 3 === 0
+        },
+        stats: {
+          likes: 1e3 + idx * 137,
+          comments: 50 + idx * 7,
+          shares: 20 + idx * 3,
+          views: 1e4 + idx * 1500
+        },
+        interaction: {
+          isLiked: false,
+          isBookmarked: false,
+          isFollowing: false
+        }
+      };
+    });
+    const hasMore = end < this.totalItems;
+    const nextCursor = hasMore ? String(page + 1) : null;
+    return { items, nextCursor, hasMore };
+  }
+};
+var MockCommentAdapter = class {
+  async fetchComments(contentId, cursor) {
+    await new Promise((r) => setTimeout(r, 300));
+    const page = cursor ? Number.parseInt(cursor, 10) : 0;
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `comment-${contentId}-${page * 10 + i}`,
+      contentId,
+      authorId: `user-${i}`,
+      authorName: `User ${i}`,
+      text: `Comment ${page * 10 + i} on ${contentId}`,
+      createdAt: Date.now() - i * 6e4,
+      likeCount: i * 3,
+      isLiked: false
+    }));
+    return { items, nextCursor: page < 2 ? String(page + 1) : null, hasMore: page < 2, total: 30 };
+  }
+  async postComment(contentId, text) {
+    return {
+      id: `comment-new-${Date.now()}`,
+      contentId,
+      authorId: "me",
+      authorName: "Me",
+      text,
+      createdAt: Date.now(),
+      likeCount: 0,
+      isLiked: false
+    };
+  }
+  async deleteComment(_id) {
+  }
+  async likeComment(_id) {
+  }
+  async unlikeComment(_id) {
+  }
+};
+
+// src/adapters/browser/HttpDataSource.ts
+function getNestedValue(obj, path) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function tryFields(obj, ...paths) {
+  for (const path of paths) {
+    const value = getNestedValue(obj, path);
+    if (value !== void 0 && value !== null) return value;
+  }
+  return void 0;
+}
+function toStr(value, fallback = "") {
+  if (value === null || value === void 0) return fallback;
+  return String(value);
+}
+function toNum(value, fallback = 0) {
+  if (value === null || value === void 0) return fallback;
+  const n = Number(value);
+  return Number.isNaN(n) ? fallback : n;
+}
+function toBool(value, fallback = false) {
+  if (value === null || value === void 0) return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value === "true" || value === "1";
+  return Boolean(value);
+}
+function transformSource(obj) {
+  const mediaArr = obj["media"];
+  if (Array.isArray(mediaArr) && mediaArr.length > 0) {
+    const first = mediaArr[0];
+    const url2 = toStr(first["url"], "");
+    const type2 = url2.includes(".m3u8") ? "hls" : "mp4";
+    return { url: url2, type: type2 };
+  }
+  const url = toStr(
+    tryFields(obj, "video_url", "url", "source_url", "playback_url", "stream_url"),
+    ""
+  );
+  const type = url.includes(".m3u8") ? "hls" : "mp4";
+  return { url, type };
+}
+function transformAuthor(obj) {
+  const authorObj = tryFields(obj, "owner", "user", "author", "creator") ?? obj;
+  const firstName = toStr(tryFields(authorObj, "first_name"), "");
+  const lastName = toStr(tryFields(authorObj, "last_name"), "");
+  const fullName = [firstName, lastName].filter(Boolean).join(" ") || toStr(
+    tryFields(authorObj, "display_name", "name", "username", "nickname"),
+    "Unknown"
+  );
+  return {
+    id: toStr(tryFields(authorObj, "id", "user_id", "author_id"), ""),
+    name: fullName || "Unknown",
+    avatar: toStr(
+      tryFields(authorObj, "avatar", "avatar_url", "profile_picture", "photo"),
+      void 0
+    ) || void 0,
+    isVerified: toBool(tryFields(authorObj, "is_verified", "verified"), false)
+  };
+}
+function transformStats(obj) {
+  return {
+    views: toNum(tryFields(obj, "views", "view_count", "play_count"), 0),
+    likes: toNum(tryFields(obj, "likes", "like_count", "digg_count"), 0),
+    comments: toNum(tryFields(obj, "total_comments", "comment_count", "comments"), 0),
+    shares: toNum(tryFields(obj, "share_count", "shares"), 0),
+    bookmarks: toNum(tryFields(obj, "bookmark_count", "bookmarks", "saves"), 0)
+  };
+}
+function transformInteraction(obj) {
+  return {
+    isLiked: toBool(tryFields(obj, "liked", "is_liked", "user_liked", "has_liked", "isLiked"), false),
+    isBookmarked: toBool(tryFields(obj, "is_bookmarked", "bookmarked", "saved", "isBookmarked"), false),
+    isFollowing: toBool(tryFields(obj, "is_following", "following", "user_following", "isFollowing"), false)
+  };
+}
+function transformVideoItem(raw) {
+  const obj = raw;
+  const source = transformSource(obj);
+  const author = transformAuthor(obj);
+  const stats = transformStats(obj);
+  const interaction = transformInteraction(obj);
+  let poster;
+  const thumbnailObj = obj["thumbnail"];
+  if (thumbnailObj && thumbnailObj["url"]) {
+    poster = toStr(thumbnailObj["url"], "") || void 0;
+  }
+  if (!poster) {
+    const mediaArr2 = obj["media"];
+    if (Array.isArray(mediaArr2) && mediaArr2.length > 0) {
+      const first = mediaArr2[0];
+      poster = toStr(first["poster"], "") || void 0;
+    }
+  }
+  if (!poster) {
+    poster = toStr(
+      tryFields(obj, "thumbnail_url", "cover", "cover_url"),
+      void 0
+    ) || void 0;
+  }
+  let duration = 0;
+  const mediaArr = obj["media"];
+  if (Array.isArray(mediaArr) && mediaArr.length > 0) {
+    const first = mediaArr[0];
+    duration = toNum(first["duration"], 0);
+  }
+  if (duration === 0) {
+    duration = toNum(tryFields(obj, "duration", "duration_seconds", "length", "video_duration"), 0);
+  }
+  return {
+    type: "video",
+    id: toStr(tryFields(obj, "id", "video_id", "_id"), ""),
+    source,
+    poster,
+    duration,
+    title: toStr(tryFields(obj, "title", "caption", "text"), void 0) || void 0,
+    description: toStr(tryFields(obj, "description", "caption", "text", "content"), void 0) || void 0,
+    author,
+    stats,
+    interaction
+  };
+}
+function transformArticleImage(raw) {
+  if (typeof raw === "string") return { url: raw };
+  const obj = raw;
+  return {
+    url: toStr(tryFields(obj, "url", "image_url", "src"), "")
+  };
+}
+function transformArticle(raw) {
+  const obj = raw;
+  const author = transformAuthor(obj);
+  const stats = transformStats(obj);
+  const interaction = transformInteraction(obj);
+  let rawImages = tryFields(obj, "images", "media", "photos", "gallery");
+  if (!Array.isArray(rawImages) || rawImages.length === 0) {
+    const single = toStr(tryFields(obj, "image", "image_url", "url", "thumbnail", "cover"), "");
+    rawImages = single ? [single] : [];
+  }
+  const images = rawImages.map(transformArticleImage);
+  return {
+    type: "article",
+    id: toStr(tryFields(obj, "id", "article_id", "post_id", "_id"), ""),
+    images,
+    title: toStr(tryFields(obj, "title", "subject"), void 0) || void 0,
+    description: toStr(tryFields(obj, "description", "caption", "text", "content"), void 0) || void 0,
+    author,
+    stats,
+    interaction
+  };
+}
+function transformContentItem(raw) {
+  const obj = raw;
+  const type = toStr(tryFields(obj, "type", "content_type", "item_type"), "reel");
+  if (type === "article" || type === "image") {
+    return transformArticle(obj);
+  }
+  return transformVideoItem(obj);
+}
+function unwrapFeedResponse(response) {
+  if (!response || typeof response !== "object") {
+    return { items: [], nextCursor: null, hasMore: false };
+  }
+  const obj = response;
+  const dataObj = obj["data"];
+  if (dataObj && typeof dataObj === "object" && !Array.isArray(dataObj)) {
+    const data = dataObj;
+    const reels = data["reels"];
+    if (Array.isArray(reels)) {
+      const nextCursor2 = toStr(tryFields(data, "next_cursor", "nextCursor", "cursor"), "") || null;
+      const hasMore2 = toBool(tryFields(data, "has_next", "has_more", "hasMore", "hasNext"), nextCursor2 !== null);
+      return { items: reels, nextCursor: nextCursor2, hasMore: hasMore2 };
+    }
+    const fallbackItems = tryFields(data, "items", "videos", "results", "content", "feeds");
+    if (Array.isArray(fallbackItems)) {
+      const nextCursor2 = toStr(tryFields(data, "next_cursor", "nextCursor", "cursor"), "") || null;
+      const hasMore2 = toBool(tryFields(data, "has_next", "has_more", "hasMore", "hasNext"), nextCursor2 !== null);
+      return { items: fallbackItems, nextCursor: nextCursor2, hasMore: hasMore2 };
+    }
+  }
+  const rawItems = Array.isArray(obj) ? obj : tryFields(obj, "items", "videos", "results", "content", "feeds");
+  const items = Array.isArray(rawItems) ? rawItems : [];
+  const nextCursor = toStr(
+    tryFields(obj, "next_cursor", "nextCursor", "cursor", "next_page_token"),
+    ""
+  ) || null;
+  const hasMore = nextCursor !== null ? true : toBool(tryFields(obj, "has_more", "hasMore", "has_next", "hasNext"), items.length > 0);
+  return { items, nextCursor, hasMore };
+}
+var HttpDataSource = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.getAccessToken = config.getAccessToken ?? (() => null);
+    this.feedPath = config.feedPath ?? "/reels";
+    this.cursorParam = config.cursorParam ?? "cursor";
+    this.limitParam = config.limitParam ?? "limit";
+    this.pageSize = config.pageSize ?? 10;
+    this.extraHeaders = config.headers ?? {};
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+    this.logger = config.logger;
+  }
+  async fetchFeed(cursor) {
+    try {
+      const params = new URLSearchParams({
+        [this.limitParam]: String(this.pageSize)
+      });
+      if (this.apiKey) {
+        params.set("api_key", this.apiKey);
+      }
+      if (cursor) {
+        params.set(this.cursorParam, cursor);
+      }
+      const url = `${this.baseUrl}${this.feedPath}?${params.toString()}`;
+      const response = await this.fetch(url);
+      const { items: rawItems, nextCursor, hasMore } = unwrapFeedResponse(response);
+      const items = rawItems.map((raw) => {
+        try {
+          return transformContentItem(raw);
+        } catch (err) {
+          this.logger?.warn("[HttpDataSource] Failed to transform item, skipping", String(err));
+          return transformVideoItem(raw);
+        }
+      });
+      this.logger?.debug(`[HttpDataSource] fetchFeed \u2014 ${items.length} items, hasMore=${hasMore}`);
+      return { items, nextCursor, hasMore };
+    } catch (err) {
+      this.logger?.error("[HttpDataSource] fetchFeed failed", String(err));
+      throw err;
+    }
+  }
+  // ─── Private helpers ───
+  async fetch(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const headers = await this.buildHeaders();
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new HttpError(response.status, `HTTP ${response.status}: ${response.statusText}`, body);
+      }
+      return response.json();
+    } catch (err) {
+      clearTimeout(timer);
+      throw err;
+    }
+  }
+  async buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.extraHeaders
+    };
+    if (!this.apiKey) {
+      const token = await this.getAccessToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    return headers;
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+};
+
+exports.DEFAULT_FEED_CONFIG = DEFAULT_FEED_CONFIG;
+exports.DEFAULT_PLAYER_CONFIG = DEFAULT_PLAYER_CONFIG;
+exports.DEFAULT_RESOURCE_CONFIG = DEFAULT_RESOURCE_CONFIG;
+exports.DefaultActions = DefaultActions;
+exports.DefaultOverlay = DefaultOverlay;
+exports.DefaultSkeleton = DefaultSkeleton;
+exports.FeedManager = FeedManager;
+exports.HttpDataSource = HttpDataSource;
+exports.HttpError = HttpError;
+exports.MockAnalytics = MockAnalytics;
+exports.MockCommentAdapter = MockCommentAdapter;
+exports.MockDataSource = MockDataSource;
+exports.MockInteraction = MockInteraction;
+exports.MockLogger = MockLogger;
+exports.MockNetworkAdapter = MockNetworkAdapter;
+exports.MockSessionStorage = MockSessionStorage;
+exports.MockVideoLoader = MockVideoLoader;
+exports.OptimisticManager = OptimisticManager;
+exports.PlayerEngine = PlayerEngine;
+exports.PlayerStatus = PlayerStatus;
+exports.ReelsFeed = ReelsFeed;
+exports.ReelsProvider = ReelsProvider;
+exports.ResourceGovernor = ResourceGovernor;
+exports.VALID_TRANSITIONS = VALID_TRANSITIONS;
+exports.VideoSlot = VideoSlot;
+exports.canPause = canPause;
+exports.canPlay = canPlay;
+exports.canSeek = canSeek;
+exports.isArticle = isArticle;
+exports.isValidTransition = isValidTransition;
+exports.isVideoItem = isVideoItem;
+exports.useFeed = useFeed;
+exports.useFeedSelector = useFeedSelector;
+exports.useHls = useHls;
+exports.usePlayer = usePlayer;
+exports.usePlayerSelector = usePlayerSelector;
+exports.usePointerGesture = usePointerGesture;
+exports.useResource = useResource;
+exports.useResourceSelector = useResourceSelector;
+exports.useSDK = useSDK;
+exports.useSnapAnimation = useSnapAnimation;