@moviie/player-expo 0.4.0

package/dist/index.cjs

@@ -0,0 +1,3934 @@
+'use strict';
+
+var playerSdk = require('@moviie/player-sdk');
+var React = require('react');
+var reactNative = require('react-native');
+var Application = require('expo-application');
+var jsxRuntime = require('react/jsx-runtime');
+var expoVideo = require('expo-video');
+var playerTypes = require('@moviie/player-types');
+var AnimatedReanimated = require('react-native-reanimated');
+var RNSvg = require('react-native-svg');
+var reactNativeSafeAreaContext = require('react-native-safe-area-context');
+var reactNativeGestureHandler = require('react-native-gesture-handler');
+var expoScreenOrientation = require('expo-screen-orientation');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var Application__namespace = /*#__PURE__*/_interopNamespace(Application);
+var AnimatedReanimated__default = /*#__PURE__*/_interopDefault(AnimatedReanimated);
+var RNSvg__default = /*#__PURE__*/_interopDefault(RNSvg);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+var MOVIIE_PLAYER_EXPO_PKG_VERSION = "0.4.0";
+var MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var MOVIIE_PLAYBACK_PROFILE = {
+  VSL: "vsl",
+  CUSTOM: "custom"
+};
+var MOVIIE_SMART_PROGRESS_CONFIG = {
+  R1: 0.18,
+  P1: 0.62,
+  R2: 0.8,
+  P2: 0.95,
+  P_MAX_BEFORE_END: 0.99
+};
+var MOVIIE_SMART_PROGRESS_FILL_TRANSITION_MS = 150;
+var MOVIIE_SMART_PROGRESS_BAR_HEIGHT_DP = 12;
+var MOVIIE_SMART_PROGRESS_Z_INDEX = 34;
+var MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX = "moviie.resume_position.";
+var MOVIIE_REMEMBER_POSITION_DEBOUNCE_MS = 5e3;
+var MOVIIE_VIDEO_DEFAULT_CONTENT_FIT = {
+  VERTICAL: "contain",
+  HORIZONTAL: "cover"
+};
+var MOVIIE_BRANDING_MARKETING_ORIGIN = "https://moviie.ai";
+var MOVIIE_WATCH_ORIGIN_DEFAULT = "https://watch.moviie.ai";
+var EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN_ENV = "EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN";
+var MOVIIE_WATCH_EMBED_JS_PATH = "/embed.js";
+var MOVIIE_PLAYER_EXPO_EMBED_JS_MARKER_ATTR = "data-moviie-player-expo-embed-js";
+var EXPO_PUBLIC_MOVIIE_API_BASE_URL_ENV = "EXPO_PUBLIC_MOVIIE_API_BASE_URL";
+var EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL_ENV = "EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL";
+var MOVIIE_BRANDING_UTM_PARAM_SOURCE = "utm_source";
+var MOVIIE_BRANDING_UTM_PARAM_MEDIUM = "utm_medium";
+var MOVIIE_BRANDING_UTM_PARAM_CAMPAIGN = "utm_campaign";
+var MOVIIE_EMBED_BRAND_UTM = {
+  SOURCE: "moviie_embed_player",
+  MEDIUM: "video_control_bar",
+  CAMPAIGN: "logo_click"
+};
+var MOVIIE_SKIN_DEFAULT_ACCENT_HEX = "#6366f1";
+var MOVIIE_SKIN_CONTROLS_AUTO_HIDE_MS = 3e3;
+var MOVIIE_SKIN_CONTROLS_FADE_MS = 240;
+var MOVIIE_SKIN_CONTROL_ICON_PX = 22;
+var MOVIIE_SKIN_LAYOUT_REFERENCE_WIDTH_PT = 390;
+var MOVIIE_SKIN_LAYOUT_SCALE_MIN = 0.72;
+var MOVIIE_SKIN_LAYOUT_SCALE_MAX = 1;
+var MOVIIE_SKIN_FLOATING_HUD_EDGE_INSET_PX = 6;
+var MOVIIE_SKIN_FLOATING_HUD_ABOVE_TIMELINE_GAP_AT_REFERENCE_PT = 0;
+var MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX = 8;
+var MOVIIE_SKIN_FLOATING_FULLSCREEN_SCRIM_DIAMETER_AT_REFERENCE_PT = 44;
+var MOVIIE_SKIN_FLOATING_FULLSCREEN_ICON_AT_REFERENCE_PT = 26;
+var MOVIIE_SKIN_FLOATING_FULLSCREEN_TOP_ICON_AT_REFERENCE_PT = 36;
+var MOVIIE_SKIN_TOP_ICON_CAST_VISUAL_SCALE = 0.65;
+var MOVIIE_SKIN_TOP_ICON_PIP_VISUAL_SCALE = 0.8;
+var MOVIIE_SKIN_TOP_ICON_FULLSCREEN_VISUAL_SCALE = 0.8;
+var MOVIIE_SKIN_FLOATING_HUD_BUTTON_GAP_AT_REFERENCE_PT = 10;
+var MOVIIE_SKIN_FLOATING_HUD_CLOCK_CORNER_RADIUS_PX = 6;
+var MOVIIE_SKIN_CHROME_SCRIM_BLACK_ALPHA = 0.5;
+var MOVIIE_SKIN_CHROME_SCRIM_BLACK_RGBA = `rgba(0,0,0,${MOVIIE_SKIN_CHROME_SCRIM_BLACK_ALPHA})`;
+var MOVIIE_SKIN_CHROME_CONTROL_REST_OPACITY = 1;
+var MOVIIE_SKIN_CHROME_CONTROL_PRESSED_OPACITY = 0.72;
+var MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX = "#000000";
+var MOVIIE_SKIN_CHROME_GRADIENT_EDGE_ALPHA = 0.62;
+var MOVIIE_SKIN_CHROME_EDGE_GRADIENT_HEIGHT_AT_REFERENCE_PT = 104;
+var MOVIIE_SKIN_CHROME_EDGE_GRADIENT_EDGE_SOLID_FADE_END_FRACTION = 0.48;
+var MOVIIE_SKIN_CHROME_EDGE_GRADIENT_MIN_CLEAR_MIDDLE_PX = 56;
+var MOVIIE_SKIN_CHROME_SVG_GRADIENT_BOTTOM_EDGE_ID = "moviie_skin_chrome_gradient_bottom_edge";
+var MOVIIE_SKIN_CHROME_SVG_GRADIENT_TOP_EDGE_ID = "moviie_skin_chrome_gradient_top_edge";
+var MOVIIE_SKIN_VOLUME_LOW_ICON_THRESHOLD = 0.45;
+var MOVIIE_SKIN_CHROME_FOREGROUND_HEX = "#ffffff";
+var MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE = {
+  LANDSCAPE_RIGHT: 7
+};
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_TRANSITION_MS = 420;
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_ROTATE_Z_DEGREES = 90;
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_ENTER_SCALE_START = 0.78;
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_VIDEO_CONTENT_FIT = "contain";
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_BACKGROUND_HEX = "#000000";
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_OVERSCAN_PX = 12;
+var MOVIIE_SKIN_CUSTOM_FULLSCREEN_HUD_EDGE_BOOST_REFERENCE_PT = 14;
+var MOVIIE_SKIN_BUFFER_UNDERRUN_LEAD_SECONDS = 0.35;
+var MOVIIE_SKIN_SEEK_JUMP_SECONDS = 10;
+var MOVIIE_SKIN_CENTER_PLAY_ICON_PX = 40;
+var MOVIIE_SKIN_CENTER_PLAY_SCRIM_DIAMETER_AT_REFERENCE_PT = 80;
+var MOVIIE_SKIN_CENTER_SEEK_SCRIM_DIAMETER_AT_REFERENCE_PT = 46;
+var MOVIIE_SKIN_SEEK_ICON_PX = 28;
+var MOVIIE_SKIN_CENTER_CLUSTER_COLUMN_GAP_PX = 12;
+var MOVIIE_SKIN_CLOCK_TEXT_FONT_SIZE_AT_REFERENCE_PT = 12;
+var MOVIIE_SKIN_TIMELINE_BAR_HEIGHT_PX = 3;
+var MOVIIE_SKIN_TIMELINE_THUMB_DIAMETER_PX = 14;
+var MOVIIE_SKIN_TIMELINE_TOUCH_PADDING_VERTICAL_PX = 0;
+var MOVIIE_SKIN_TIMELINE_TOUCH_EXPANSION_VERTICAL_DP = 2;
+var MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_HORIZONTAL_DP = 3;
+var MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_TOP_DP = 2;
+var MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_BOTTOM_DP = 14;
+var MOVIIE_SKIN_TIMELINE_RAIL_BACKGROUND_RGBA = "rgba(255,255,255,0.3)";
+var MOVIIE_SKIN_TIMELINE_BUFFER_LAYER_RGBA = MOVIIE_SKIN_TIMELINE_RAIL_BACKGROUND_RGBA;
+var MOVIIE_SKIN_TIMELINE_THUMB_BORDER_RGBA = "rgba(0,0,0,0.35)";
+var MOVIIE_SKIN_TIMELINE_THUMB_DRAG_DIAMETER_MULTIPLIER = 1.65;
+var MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS = 0.15;
+var MOVIIE_SKIN_TIMELINE_CHAPTER_SNAP_THRESHOLD_SECONDS = 2;
+var MOVIIE_SKIN_BUFFERING_INDICATOR_SLOT_PX = 28;
+var MOVIIE_SKIN_BRAND_MARK_ARTBOARD_WIDTH_PX = 173;
+var MOVIIE_SKIN_BRAND_MARK_ARTBOARD_HEIGHT_PX = 46;
+var MOVIIE_SKIN_BRAND_MARK_TARGET_WIDTH_AT_REFERENCE_PT = 68;
+var MOVIIE_EMBED_BRAND_VIEW_BOX = "0 0 173 46";
+var MOVIIE_EMBED_BRAND_LETTERMARK_STROKE_WIDTH = 3;
+
+// src/apply-expo-moviie-endpoints.ts
+function normalize(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed.replace(/\/+$/, "") : void 0;
+}
+var devMode = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+if (devMode) {
+  const apiBaseUrl = normalize(process.env[EXPO_PUBLIC_MOVIIE_API_BASE_URL_ENV]);
+  const eventsBaseUrl = normalize(process.env[EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL_ENV]);
+  const opts = {};
+  if (apiBaseUrl != null) opts.apiBaseUrl = apiBaseUrl;
+  if (eventsBaseUrl != null) opts.eventsBaseUrl = eventsBaseUrl;
+  if (opts.apiBaseUrl != null || opts.eventsBaseUrl != null) {
+    playerSdk.configureMoviieEndpoints(opts);
+  }
+}
+
+// src/lib/warn-once.ts
+var FIRED_KEYS = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (FIRED_KEYS.has(key)) {
+    return;
+  }
+  FIRED_KEYS.add(key);
+  console.warn(message);
+}
+
+// src/secure-store-viewer-token-store.ts
+var MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY = "moviie_viewer_token_v1";
+var SECURE_STORE_MISSING_WARNING = "[@moviie/player-expo] `expo-secure-store` n\xE3o est\xE1 instalado \u2014 viewer token ser\xE1 mantido apenas em mem\xF3ria (perde ao matar app). Instala com `pnpm add expo-secure-store` se quiseres persist\xEAncia entre sess\xF5es.";
+function isStoredEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.token === "string" && typeof v.expiresAt === "number";
+}
+var SecureStoreViewerTokenStore = class {
+  fallback;
+  storageKey;
+  constructor(options) {
+    this.fallback = options?.fallback ?? new playerSdk.MemoryViewerTokenStore();
+    this.storageKey = options?.storageKey ?? MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY;
+  }
+  async loadSecureStore() {
+    try {
+      return await import('expo-secure-store');
+    } catch {
+      warnOnce("moviie:expo-secure-store-missing", SECURE_STORE_MISSING_WARNING);
+      return null;
+    }
+  }
+  async get() {
+    const SecureStore = await this.loadSecureStore();
+    if (!SecureStore) {
+      return this.fallback.get();
+    }
+    try {
+      const raw = await SecureStore.getItemAsync(this.storageKey);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (!isStoredEnvelope(parsed)) {
+        await SecureStore.deleteItemAsync(this.storageKey).catch(() => {
+        });
+        return null;
+      }
+      if (parsed.expiresAt <= Date.now()) {
+        await SecureStore.deleteItemAsync(this.storageKey).catch(() => {
+        });
+        return null;
+      }
+      return parsed.token;
+    } catch {
+      return this.fallback.get();
+    }
+  }
+  async set(token, ttlSec) {
+    const SecureStore = await this.loadSecureStore();
+    const envelope = {
+      token,
+      expiresAt: Date.now() + Math.max(0, ttlSec) * 1e3
+    };
+    if (!SecureStore) {
+      await this.fallback.set(token, ttlSec);
+      return;
+    }
+    try {
+      await SecureStore.setItemAsync(this.storageKey, JSON.stringify(envelope));
+    } catch {
+      await this.fallback.set(token, ttlSec);
+    }
+  }
+};
+function readNativeApplicationId() {
+  try {
+    const id = Application__namespace.applicationId;
+    return id ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/platform/platform-client-info.ts
+var cached = null;
+function buildPlatformClientInfo(sdkVersion) {
+  if (cached) {
+    return cached;
+  }
+  const os = reactNative.Platform.OS;
+  const platform = os === "ios" ? "ios" : os === "android" ? "android" : "web";
+  const bundleId = platform === "web" ? void 0 : readNativeApplicationId();
+  cached = {
+    platform,
+    bundleId,
+    sdkVersion
+  };
+  return cached;
+}
+var MoviieContext = React.createContext(null);
+var fallbackContext = null;
+function getOrCreateFallbackContext() {
+  if (!fallbackContext) {
+    const sdkVersion = MOVIIE_PLAYER_EXPO_PKG_VERSION;
+    const clientInfo = buildPlatformClientInfo(sdkVersion);
+    const viewerTokenStore = new playerSdk.MemoryViewerTokenStore();
+    const client = new playerSdk.MoviieClient({
+      publishableKey: void 0,
+      clientInfo,
+      sdkVersion
+    });
+    fallbackContext = {
+      client,
+      viewerTokenStore,
+      publishableKey: null,
+      clientInfo,
+      sdkVersion,
+      telemetryHeaders: playerSdk.buildClientHeaders({
+        clientInfo,
+        sdkVersion
+      })
+    };
+  }
+  return fallbackContext;
+}
+function useMoviieContext() {
+  const ctx = React.useContext(MoviieContext);
+  return ctx ?? getOrCreateFallbackContext();
+}
+function MoviieProvider({
+  publishableKey,
+  children
+}) {
+  const value = React.useMemo(() => {
+    const sdkVersion = MOVIIE_PLAYER_EXPO_PKG_VERSION;
+    const clientInfo = buildPlatformClientInfo(sdkVersion);
+    const trimmedKey = publishableKey?.trim();
+    const viewerTokenStore = new SecureStoreViewerTokenStore();
+    const client = new playerSdk.MoviieClient({
+      publishableKey: trimmedKey || void 0,
+      clientInfo,
+      sdkVersion
+    });
+    const telemetryHeaders = playerSdk.buildClientHeaders({
+      publishableKey: trimmedKey || void 0,
+      clientInfo,
+      sdkVersion
+    });
+    return {
+      client,
+      viewerTokenStore,
+      publishableKey: trimmedKey ?? null,
+      clientInfo,
+      sdkVersion,
+      telemetryHeaders
+    };
+  }, [publishableKey]);
+  return /* @__PURE__ */ jsxRuntime.jsx(MoviieContext.Provider, { value, children });
+}
+
+// src/playback/playback-memory-cache.ts
+var playbackCache = /* @__PURE__ */ new Map();
+function cacheKey(scope, embedId) {
+  return `${scope ?? "__anon__"}::${embedId}`;
+}
+function resolveEntryExpiry(data) {
+  const now = Date.now();
+  const fallback = now + MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS;
+  const serverExpiry = data.playback?.expiresAt;
+  if (!serverExpiry) return fallback;
+  const parsed = Date.parse(serverExpiry);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(fallback, parsed);
+}
+function readPlaybackCache(scope, embedId) {
+  const key = cacheKey(scope, embedId);
+  const hit = playbackCache.get(key);
+  if (!hit || hit.expiresAt <= Date.now()) {
+    playbackCache.delete(key);
+    return null;
+  }
+  return hit.data;
+}
+function writePlaybackCache(scope, embedId, data) {
+  playbackCache.set(cacheKey(scope, embedId), {
+    data,
+    expiresAt: resolveEntryExpiry(data)
+  });
+}
+
+// src/playback/fetch-playback-fresh.ts
+async function fetchPlaybackFreshWriteCache(scope, embedId, signal, getPlayback) {
+  try {
+    const data = await getPlayback(embedId, signal);
+    writePlaybackCache(scope, embedId, data);
+    return { ok: true, data };
+  } catch (unknownError) {
+    const error = unknownError instanceof Error ? unknownError : new Error(String(unknownError));
+    return { ok: false, error };
+  }
+}
+
+// src/hooks/use-moviie-playback.ts
+function useMoviiePlayback(args) {
+  const trimmedEmbedId = args.embedId?.trim();
+  const missingEmbedId = !trimmedEmbedId;
+  const { client, publishableKey } = useMoviieContext();
+  const [data, setData] = React.useState(null);
+  const [fetchError, setFetchError] = React.useState(null);
+  const [isLoading, setIsLoading] = React.useState(!missingEmbedId);
+  const [retryNonce, setRetryNonce] = React.useState(0);
+  const retry = React.useCallback(() => {
+    setRetryNonce((n) => n + 1);
+  }, []);
+  React.useEffect(() => {
+    if (!trimmedEmbedId) {
+      return;
+    }
+    const embedKey = trimmedEmbedId;
+    const controller = new AbortController();
+    let cancelled = false;
+    async function load() {
+      setIsLoading(true);
+      setFetchError(null);
+      try {
+        const cached2 = readPlaybackCache(publishableKey, embedKey);
+        if (cached2 && !controller.signal.aborted) {
+          setData(cached2);
+        }
+        const outcome = await fetchPlaybackFreshWriteCache(
+          publishableKey,
+          embedKey,
+          controller.signal,
+          (id, sig) => client.getPlayback(id, sig)
+        );
+        if (cancelled || controller.signal.aborted) {
+          return;
+        }
+        if (outcome.ok) {
+          setData(outcome.data);
+        } else {
+          setFetchError(outcome.error);
+          setData(readPlaybackCache(publishableKey, embedKey));
+        }
+      } finally {
+        if (!cancelled && !controller.signal.aborted) {
+          setIsLoading(false);
+        }
+      }
+    }
+    void load();
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [trimmedEmbedId, client, publishableKey, retryNonce]);
+  const error = missingEmbedId ? new Error("Informe um embedId v\xE1lido (UUID p\xFAblico do embed).") : fetchError;
+  return {
+    data: missingEmbedId ? null : data,
+    error,
+    isLoading: missingEmbedId ? false : isLoading,
+    retry
+  };
+}
+function useMoviieTelemetry(player, playback, eventsBaseUrl, defaultHeaders, viewerTokenStore) {
+  const hasStartedPlaybackRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!playback?.telemetry.bootstrapUrl) {
+      return;
+    }
+    const telemetry = new playerSdk.TelemetryClient({
+      eventsBaseUrl,
+      defaultHeaders,
+      viewerTokenStore,
+      getPositionSeconds: () => player.currentTime
+    });
+    let disposed = false;
+    const subs = [];
+    void (async () => {
+      try {
+        await telemetry.bootstrap({
+          bootstrapUrl: playback.telemetry.bootstrapUrl
+        });
+        if (disposed) {
+          return;
+        }
+        await telemetry.recordEvent({
+          eventType: playerSdk.PLAYBACK_EVENT_TYPE.SESSION_START,
+          positionSeconds: 0
+        });
+      } catch {
+      }
+    })();
+    subs.push(
+      player.addListener("playingChange", ({ isPlaying }) => {
+        telemetry.updatePosition(Math.max(0, player.currentTime));
+        if (isPlaying) {
+          void telemetry.recordEvent({
+            eventType: hasStartedPlaybackRef.current ? playerSdk.PLAYBACK_EVENT_TYPE.RESUME : playerSdk.PLAYBACK_EVENT_TYPE.PLAY_START,
+            positionSeconds: Math.floor(Math.max(0, player.currentTime))
+          });
+          hasStartedPlaybackRef.current = true;
+          telemetry.startHeartbeats();
+        } else {
+          void telemetry.recordEvent({
+            eventType: playerSdk.PLAYBACK_EVENT_TYPE.PAUSE,
+            positionSeconds: Math.floor(Math.max(0, player.currentTime))
+          });
+          telemetry.stopHeartbeats();
+        }
+      })
+    );
+    subs.push(
+      player.addListener("playToEnd", () => {
+        telemetry.updatePosition(Math.max(0, player.currentTime));
+        void telemetry.recordEvent({
+          eventType: playerSdk.PLAYBACK_EVENT_TYPE.ENDED,
+          positionSeconds: Math.floor(Math.max(0, player.duration))
+        });
+        telemetry.stopHeartbeats();
+      })
+    );
+    subs.push(
+      player.addListener("statusChange", ({ status }) => {
+        if (status === "error") {
+          void telemetry.recordEvent({
+            eventType: playerSdk.PLAYBACK_EVENT_TYPE.ERROR,
+            positionSeconds: Math.floor(Math.max(0, player.currentTime)),
+            errorCode: "player_status_error"
+          });
+        }
+      })
+    );
+    subs.push(
+      player.addListener("timeUpdate", ({ currentTime }) => {
+        telemetry.updatePosition(Math.max(0, currentTime));
+      })
+    );
+    const appStateSub = reactNative.AppState.addEventListener(
+      "change",
+      (next) => {
+        if (next === "active") {
+          telemetry.resumeHeartbeats();
+        } else {
+          telemetry.pauseHeartbeats();
+          void telemetry.flush();
+        }
+      }
+    );
+    return () => {
+      disposed = true;
+      hasStartedPlaybackRef.current = false;
+      subs.forEach((s) => {
+        s.remove();
+      });
+      appStateSub.remove();
+      void telemetry.destroy();
+    };
+  }, [
+    player,
+    playback?.embedId,
+    playback?.telemetry.bootstrapUrl,
+    eventsBaseUrl,
+    defaultHeaders,
+    viewerTokenStore
+  ]);
+}
+
+// src/lib/remember-playback-position-storage.ts
+var RESUME_SECURE_STORE_MISSING_WARNING = "[@moviie/player-expo] `expo-secure-store` n\xE3o est\xE1 instalado \u2014 resume position n\xE3o ser\xE1 persistido. Instala com `pnpm add expo-secure-store` se quiseres retomar onde o utilizador parou.";
+var SECURE_STORE_KEY_SAFE_PATTERN = /^[A-Za-z0-9._-]+$/;
+function isSecureStoreSafeEmbedId(embedId) {
+  return SECURE_STORE_KEY_SAFE_PATTERN.test(embedId);
+}
+function rememberPlaybackPositionStorageKey(embedId) {
+  return `${MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX}${embedId}`;
+}
+function parseStoredResumeSeconds(raw) {
+  if (raw == null || raw === "") {
+    return null;
+  }
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) {
+    return null;
+  }
+  return n;
+}
+function clampResumeTimeSeconds(seconds, durationSeconds) {
+  if (seconds == null || !Number.isFinite(seconds) || seconds < 0.25) {
+    return null;
+  }
+  if (durationSeconds != null && Number.isFinite(durationSeconds) && durationSeconds > 0) {
+    if (seconds >= durationSeconds - 1) {
+      return null;
+    }
+    return Math.min(seconds, durationSeconds - 0.25);
+  }
+  return seconds;
+}
+async function loadSecureStore() {
+  try {
+    return await import('expo-secure-store');
+  } catch {
+    warnOnce("moviie:expo-secure-store-missing-resume", RESUME_SECURE_STORE_MISSING_WARNING);
+    return null;
+  }
+}
+async function readStoredResumeSeconds(embedId) {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return null;
+  }
+  const SecureStore = await loadSecureStore();
+  if (!SecureStore) {
+    return null;
+  }
+  try {
+    const raw = await SecureStore.getItemAsync(rememberPlaybackPositionStorageKey(embedId));
+    return parseStoredResumeSeconds(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeStoredResumeSeconds(embedId, seconds) {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return;
+  }
+  const SecureStore = await loadSecureStore();
+  if (!SecureStore) {
+    return;
+  }
+  try {
+    await SecureStore.setItemAsync(rememberPlaybackPositionStorageKey(embedId), String(seconds));
+  } catch {
+    return;
+  }
+}
+async function clearStoredResumeSeconds(embedId) {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return;
+  }
+  const SecureStore = await loadSecureStore();
+  if (!SecureStore) {
+    return;
+  }
+  try {
+    await SecureStore.deleteItemAsync(rememberPlaybackPositionStorageKey(embedId));
+  } catch {
+    return;
+  }
+}
+
+// src/hooks/use-moviie-playback-resume-persistence.ts
+function useMoviiePlaybackResumePersistence(options) {
+  const { player, embedId, durationSeconds, enabled } = options;
+  const debounceTimerRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!enabled || embedId == null || embedId === "") {
+      return;
+    }
+    const clearDebounce = () => {
+      if (debounceTimerRef.current != null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+    };
+    const persistNow = (seconds) => {
+      const clamped = clampResumeTimeSeconds(seconds, durationSeconds);
+      if (clamped == null) {
+        void clearStoredResumeSeconds(embedId);
+        return;
+      }
+      void writeStoredResumeSeconds(embedId, clamped);
+    };
+    const schedulePersist = (seconds) => {
+      clearDebounce();
+      debounceTimerRef.current = setTimeout(() => {
+        debounceTimerRef.current = null;
+        persistNow(seconds);
+      }, MOVIIE_REMEMBER_POSITION_DEBOUNCE_MS);
+    };
+    const subTime = player.addListener("timeUpdate", ({ currentTime }) => {
+      if (player.playing) {
+        schedulePersist(currentTime);
+      }
+    });
+    const subPlaying = player.addListener("playingChange", ({ isPlaying }) => {
+      if (!isPlaying) {
+        clearDebounce();
+        persistNow(player.currentTime);
+      }
+    });
+    const subEnd = player.addListener("playToEnd", () => {
+      clearDebounce();
+      void clearStoredResumeSeconds(embedId);
+    });
+    return () => {
+      clearDebounce();
+      subTime.remove();
+      subPlaying.remove();
+      subEnd.remove();
+    };
+  }, [durationSeconds, embedId, enabled, player]);
+}
+
+// src/lib/build-moviie-video-presentation.ts
+function buildMoviieVideoPresentationProps(args) {
+  const allowsPictureInPicture = args.pictureInPicture !== void 0 ? args.pictureInPicture : args.showPip;
+  return {
+    allowsPictureInPicture,
+    startsPictureInPictureAutomatically: args.pictureInPictureAutoStart ?? false,
+    requiresLinearPlayback: args.profile === MOVIIE_PLAYBACK_PROFILE.VSL
+  };
+}
+
+// src/hooks/use-moviie-player.ts
+var PLAYBACK_REQUEST_HEADER_ALLOWLIST = /* @__PURE__ */ new Set([
+  "authorization",
+  "referer",
+  "user-agent",
+  "x-moviie-playback-token",
+  "x-moviie-signature",
+  "x-playback-token"
+]);
+function filterPlaybackRequestHeaders(raw) {
+  if (!raw) return void 0;
+  const safe = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (typeof name !== "string" || typeof value !== "string") continue;
+    if (!PLAYBACK_REQUEST_HEADER_ALLOWLIST.has(name.toLowerCase())) continue;
+    if (/[\r\n]/.test(value)) continue;
+    safe[name] = value;
+  }
+  return Object.keys(safe).length > 0 ? safe : void 0;
+}
+function buildVideoSource(data) {
+  const headers = filterPlaybackRequestHeaders(data.playback.requestHeaders);
+  const base = {
+    uri: data.playback.uri,
+    metadata: {
+      title: data.title,
+      artist: data.branding.organizationName ?? void 0,
+      artwork: data.posterUrl ?? void 0
+    }
+  };
+  if (headers) {
+    return { ...base, headers };
+  }
+  return base;
+}
+function configurePlaybackDefaults(player, data) {
+  const c = data.controls;
+  player.loop = c.loop;
+  player.muted = c.muted;
+  player.timeUpdateEventInterval = 1;
+}
+function applyNativePlaybackPresentation(player, opts) {
+  player.staysActiveInBackground = opts.backgroundPlayback ?? false;
+  player.showNowPlayingNotification = opts.lockScreenNowPlaying ?? false;
+}
+function syncPlaybackIntent(player, shouldPlay) {
+  if (shouldPlay) {
+    player.play();
+  } else {
+    player.pause();
+  }
+}
+var EMPTY_PRESENTATION = buildMoviieVideoPresentationProps({
+  profile: "",
+  showPip: false
+});
+function useMoviiePlayer(options) {
+  const ctx = useMoviieContext();
+  const { data, error, isLoading, retry } = useMoviiePlayback({
+    embedId: options.embedId
+  });
+  const rememberEnabled = React.useMemo(() => {
+    if (options.rememberPosition === false) {
+      return false;
+    }
+    if (options.rememberPosition === true) {
+      return true;
+    }
+    return data?.controls.rememberPosition === true;
+  }, [data?.controls.rememberPosition, options.rememberPosition]);
+  const player = expoVideo.useVideoPlayer(null, (initialPlayer) => {
+    initialPlayer.timeUpdateEventInterval = 1;
+  });
+  useMoviiePlaybackResumePersistence({
+    durationSeconds: data?.durationSeconds,
+    embedId: data?.embedId,
+    enabled: rememberEnabled && data != null,
+    player
+  });
+  const resumeHandledRef = React.useRef(false);
+  React.useEffect(() => {
+    resumeHandledRef.current = false;
+  }, [data?.embedId, data?.playback.uri]);
+  React.useEffect(() => {
+    if (!data) {
+      return;
+    }
+    const src = buildVideoSource(data);
+    const shouldPlay = options.autoplay !== void 0 ? options.autoplay : data.controls.autoplay;
+    player.replace(src);
+    configurePlaybackDefaults(player, data);
+    applyNativePlaybackPresentation(player, {
+      backgroundPlayback: options.backgroundPlayback,
+      lockScreenNowPlaying: options.lockScreenNowPlaying
+    });
+    const restoreAndSync = async () => {
+      if (player.status !== "readyToPlay") {
+        return;
+      }
+      if (!resumeHandledRef.current) {
+        resumeHandledRef.current = true;
+        if (rememberEnabled) {
+          const stored = await readStoredResumeSeconds(data.embedId);
+          const clamped = clampResumeTimeSeconds(stored, data.durationSeconds);
+          if (clamped != null) {
+            player.currentTime = clamped;
+          }
+        }
+      }
+      syncPlaybackIntent(player, shouldPlay);
+    };
+    const sub = player.addListener("statusChange", (payload) => {
+      if (payload.status === "readyToPlay") {
+        void restoreAndSync();
+      }
+    });
+    void restoreAndSync();
+    return () => {
+      sub.remove();
+    };
+  }, [
+    data,
+    player,
+    options.autoplay,
+    options.backgroundPlayback,
+    options.lockScreenNowPlaying,
+    rememberEnabled
+  ]);
+  const videoPresentation = React.useMemo(() => {
+    if (!data) {
+      return EMPTY_PRESENTATION;
+    }
+    return buildMoviieVideoPresentationProps({
+      pictureInPicture: options.pictureInPicture,
+      pictureInPictureAutoStart: options.pictureInPictureAutoStart,
+      profile: data.profile,
+      showPip: data.controls.showPip
+    });
+  }, [
+    data,
+    options.pictureInPicture,
+    options.pictureInPictureAutoStart
+  ]);
+  const eventsBaseUrl = data?.telemetry.bootstrapUrl != null ? playerSdk.deriveTelemetryEventsBaseUrlFromBootstrapUrl(data.telemetry.bootstrapUrl) ?? ctx.client.getEventsBaseUrl() : ctx.client.getEventsBaseUrl();
+  useMoviieTelemetry(
+    player,
+    data,
+    eventsBaseUrl,
+    ctx.telemetryHeaders,
+    ctx.viewerTokenStore
+  );
+  return {
+    player,
+    playback: data,
+    error,
+    isLoading,
+    videoPresentation,
+    retry
+  };
+}
+function useMoviieEvent(player, eventName, handler) {
+  React.useEffect(() => {
+    if (!player) {
+      return;
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.TIME_UPDATE) {
+      const previousInterval = player.timeUpdateEventInterval;
+      if (player.timeUpdateEventInterval <= 0) {
+        player.timeUpdateEventInterval = 0.25;
+      }
+      const sub = player.addListener("timeUpdate", () => {
+        handler();
+      });
+      return () => {
+        sub.remove();
+        player.timeUpdateEventInterval = previousInterval;
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.PLAY) {
+      const sub = player.addListener("playingChange", ({ isPlaying }) => {
+        if (isPlaying) {
+          handler();
+        }
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.PAUSE) {
+      const sub = player.addListener("playingChange", ({ isPlaying }) => {
+        if (!isPlaying) {
+          handler();
+        }
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.ENDED) {
+      const sub = player.addListener("playToEnd", () => {
+        handler();
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.DURATION_CHANGE) {
+      const sub = player.addListener("sourceChange", () => {
+        handler();
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.VOLUME_CHANGE) {
+      const sub = player.addListener("volumeChange", () => {
+        handler();
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (eventName === playerTypes.PLAYER_API_EVENTS.READY) {
+      const sub = player.addListener("statusChange", ({ status }) => {
+        if (status === "readyToPlay") {
+          handler();
+        }
+      });
+      return () => {
+        sub.remove();
+      };
+    }
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn(
+        `[@moviie/player-expo] useMoviieEvent: "${eventName}" n\xE3o tem mapeamento para expo-video nesta vers\xE3o`
+      );
+    }
+    return void 0;
+  }, [player, eventName, handler]);
+}
+function useMoviiePlaybackEnded(player, onEnded) {
+  useMoviieEvent(player, playerTypes.PLAYER_API_EVENTS.ENDED, onEnded);
+}
+
+// src/lib/compute-moviie-playback-ended.ts
+function computeMoviiePlaybackEnded(args) {
+  if (args.loop) {
+    return false;
+  }
+  if (args.isLive) {
+    return false;
+  }
+  if (args.playing) {
+    return false;
+  }
+  if (!Number.isFinite(args.duration) || args.duration <= 0) {
+    return false;
+  }
+  if (!Number.isFinite(args.currentTime)) {
+    return false;
+  }
+  return args.currentTime >= args.duration - MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS;
+}
+
+// src/lib/add-moviie-playback-ended-listener.ts
+function addMoviiePlaybackEndedListener(player, onEnded) {
+  const sub = player.addListener("playToEnd", onEnded);
+  return { remove: () => sub.remove() };
+}
+
+// src/lib/build-moviie-watch-embed-url.ts
+function normalizeWatchOrigin(origin) {
+  return origin.trim().replace(/\/+$/, "");
+}
+function buildMoviieWatchEmbedUrl(embedId, watchOrigin) {
+  const base = normalizeWatchOrigin(watchOrigin);
+  const id = embedId.trim();
+  return `${base}/embed/${encodeURIComponent(id)}`;
+}
+function resolveMoviieWatchOrigin() {
+  try {
+    const raw = typeof process !== "undefined" ? process.env.EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN?.trim() : void 0;
+    if (raw) {
+      return normalizeWatchOrigin(raw);
+    }
+  } catch {
+  }
+  return MOVIIE_WATCH_ORIGIN_DEFAULT;
+}
+var Svg = RNSvg__default.default;
+var jsx_native_bridge_default = Svg;
+var Path = RNSvg.Path;
+var Defs = RNSvg.Defs;
+var LinearGradient = RNSvg.LinearGradient;
+var Rect = RNSvg.Rect;
+var Stop = RNSvg.Stop;
+var AnimatedView = reactNative.Animated.View;
+var ReanimatedView = AnimatedReanimated__default.default.View;
+
+// src/lib/moviie-telemetry-callbacks.ts
+function safeInvokeMoviieTelemetry(callback, ...args) {
+  if (callback == null) {
+    return;
+  }
+  try {
+    callback(...args);
+  } catch (err) {
+    console.warn("[@moviie/player-expo] telemetry callback threw \u2014 ignorado", err);
+  }
+}
+
+// src/lib/moviie-shell-tokens.ts
+var MOVIIE_SHELL_BACKGROUND_HEX = "#0a0a0a";
+var MOVIIE_SHELL_RADIAL_INNER_HEX = "#1a1a1a";
+var MOVIIE_SHELL_HEADING_HEX = "#f8fafc";
+var MOVIIE_SHELL_DESCRIPTION_HEX = "#e5e7eb";
+var MOVIIE_SHELL_ERROR_CODE_HEX = "#4b5563";
+var MOVIIE_SHELL_BUTTON_BG_HEX = "#0a0a0a";
+var MOVIIE_SHELL_BUTTON_BORDER_RGBA = "rgba(255,255,255,0.15)";
+var MOVIIE_SHELL_BUTTON_LABEL_HEX = "#f8fafc";
+var MOVIIE_SHELL_HEADING_FONT_SIZE_PX = 22;
+var MOVIIE_SHELL_DESCRIPTION_FONT_SIZE_PX = 14;
+var MOVIIE_SHELL_BUTTON_LABEL_FONT_SIZE_PX = 14;
+var MOVIIE_SHELL_CONTENT_MAX_WIDTH_PX = 280;
+var MOVIIE_SHELL_BUTTON_PADDING_H_PX = 22;
+var MOVIIE_SHELL_BUTTON_PADDING_V_PX = 12;
+var MOVIIE_SHELL_BUTTON_RADIUS_PX = 9999;
+var MOVIIE_SHELL_CROSSFADE_DURATION_MS = 240;
+var MOVIIE_SHELL_DEFAULT_ASPECT_RATIO = 16 / 9;
+var MOVIIE_DASHBOARD_URL = "https://app.moviie.ai";
+
+// src/lib/partition-moviie-video-host-style.ts
+var VIDEO_SURFACE_STYLE_KEYS = /* @__PURE__ */ new Set([
+  "backgroundColor",
+  "borderRadius",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderCurve",
+  "borderWidth",
+  "borderColor"
+]);
+function partitionMoviieVideoHostStyle(flatStyle) {
+  if (flatStyle == null || Object.keys(flatStyle).length === 0) {
+    return { columnStyle: void 0, surfaceStyle: void 0 };
+  }
+  const flat = flatStyle;
+  const column = {};
+  const surface = {};
+  for (const key of Object.keys(flat)) {
+    const value = flat[key];
+    if (value === void 0) {
+      continue;
+    }
+    if (VIDEO_SURFACE_STYLE_KEYS.has(key)) {
+      surface[key] = value;
+    } else {
+      column[key] = value;
+    }
+  }
+  return {
+    columnStyle: Object.keys(column).length > 0 ? column : void 0,
+    surfaceStyle: Object.keys(surface).length > 0 ? surface : void 0
+  };
+}
+
+// src/lib/compute-custom-fullscreen-stage-dimensions.ts
+function computeCustomFullscreenStageDimensions(args) {
+  const pad = args.stageOverscanPx;
+  const usableW = Math.max(
+    0,
+    args.windowWidth - args.safeInsets.left - args.safeInsets.right - 2 * pad
+  );
+  const usableH = Math.max(
+    0,
+    args.windowHeight - args.safeInsets.top - args.safeInsets.bottom - 2 * pad
+  );
+  const longSide = Math.max(usableW, usableH);
+  const shortSide = Math.min(usableW, usableH);
+  return {
+    longSide,
+    shortSide,
+    layoutMetricsBasisWidth: longSide
+  };
+}
+
+// src/lib/cast-adapter-registry.ts
+var _registered = null;
+function getRegisteredCastAdapter() {
+  return _registered;
+}
+
+// src/lib/format-playback-clock.ts
+function pad2(value) {
+  return String(Math.floor(value)).padStart(2, "0");
+}
+function formatSegment(totalSeconds) {
+  if (!Number.isFinite(totalSeconds) || totalSeconds < 0) {
+    return "0:00";
+  }
+  const seconds = totalSeconds % 60;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const hours = Math.floor(totalSeconds / 3600);
+  if (hours > 0) {
+    return `${hours}:${pad2(minutes)}:${pad2(seconds)}`;
+  }
+  return `${Math.floor(minutes)}:${pad2(seconds)}`;
+}
+function formatPlaybackClock(currentSeconds, durationSeconds) {
+  const current = formatSegment(currentSeconds);
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+    return current;
+  }
+  return `${current} / ${formatSegment(durationSeconds)}`;
+}
+var MOVIIE_EMBED_MEDIA_ICON_VIEW_BOX = "0 0 32 32";
+function IconShell({
+  size,
+  children
+}) {
+  const pixels = size ?? 22;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    jsx_native_bridge_default,
+    {
+      accessibilityElementsHidden: true,
+      height: pixels,
+      importantForAccessibility: "no",
+      viewBox: MOVIIE_EMBED_MEDIA_ICON_VIEW_BOX,
+      width: pixels,
+      children
+    }
+  );
+}
+function EmbedMediaIconPlay(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(IconShell, { size: props.size, children: /* @__PURE__ */ jsxRuntime.jsx(
+    Path,
+    {
+      d: "M10.6667 6.6548C10.6667 6.10764 11.2894 5.79346 11.7295 6.11862L24.377 15.4634C24.7377 15.7298 24.7377 16.2692 24.3771 16.5357L11.7295 25.8813C11.2895 26.2065 10.6667 25.8923 10.6667 25.3451L10.6667 6.6548Z",
+      fill: props.color
+    }
+  ) });
+}
+function EmbedMediaIconPause(props) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(IconShell, { size: props.size, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M8.66667 6.66667C8.29848 6.66667 8 6.96514 8 7.33333V24.6667C8 25.0349 8.29848 25.3333 8.66667 25.3333H12.6667C13.0349 25.3333 13.3333 25.0349 13.3333 24.6667V7.33333C13.3333 6.96514 13.0349 6.66667 12.6667 6.66667H8.66667Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M19.3333 6.66667C18.9651 6.66667 18.6667 6.96514 18.6667 7.33333V24.6667C18.6667 25.0349 18.9651 25.3333 19.3333 25.3333H23.3333C23.7015 25.3333 24 25.0349 24 24.6667V7.33333C24 6.96514 23.7015 6.66667 23.3333 6.66667H19.3333Z",
+        fill: props.color
+      }
+    )
+  ] });
+}
+function EmbedMediaIconReplay(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(IconShell, { size: props.size, children: /* @__PURE__ */ jsxRuntime.jsx(
+    Path,
+    {
+      d: "M15.6038 12.2147C16.0439 12.5399 16.6667 12.2257 16.6667 11.6786V10.1789C16.6667 10.1001 16.7351 10.0384 16.8134 10.0479C20.1116 10.4494 22.6667 13.2593 22.6667 16.6659C22.6667 20.3481 19.6817 23.3332 15.9995 23.3332C12.542 23.3332 9.69927 20.7014 9.36509 17.332C9.32875 16.9655 9.03371 16.6662 8.66548 16.6662L6.66655 16.6666C6.29841 16.6666 5.99769 16.966 6.02187 17.3334C6.36494 22.5454 10.7012 26.6667 16 26.6667C21.5228 26.6667 26 22.1895 26 16.6667C26 11.4103 21.9444 7.10112 16.7916 6.69757C16.7216 6.69209 16.6667 6.63396 16.6667 6.56372V4.98824C16.6667 4.44106 16.0439 4.12689 15.6038 4.45206L11.0765 7.79738C10.7159 8.06387 10.7159 8.60326 11.0766 8.86973L15.6038 12.2147Z",
+      fill: props.color
+    }
+  ) });
+}
+function EmbedMediaIconSeekBackward10(props) {
+  const fill = props.color;
+  return /* @__PURE__ */ jsxRuntime.jsxs(IconShell, { size: props.size, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M16.6667 10.3452C16.6667 10.8924 16.0439 11.2066 15.6038 10.8814L11.0766 7.5364C10.7159 7.26993 10.7159 6.73054 11.0766 6.46405L15.6038 3.11873C16.0439 2.79356 16.6667 3.10773 16.6667 3.6549V5.22682C16.6667 5.29746 16.7223 5.35579 16.7927 5.36066C22.6821 5.76757 27.3333 10.674 27.3333 16.6667C27.3333 22.9259 22.2592 28 16 28C9.96483 28 5.03145 23.2827 4.68601 17.3341C4.66466 16.9665 4.96518 16.6673 5.33339 16.6673H7.3334C7.70157 16.6673 7.99714 16.9668 8.02743 17.3337C8.36638 21.4399 11.8064 24.6667 16 24.6667C20.4183 24.6667 24 21.085 24 16.6667C24 12.5225 20.8483 9.11428 16.8113 8.70739C16.7337 8.69957 16.6667 8.76096 16.6667 8.83893V10.3452Z",
+        fill
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        clipRule: "evenodd",
+        d: "M17.0879 19.679C17.4553 19.9195 17.8928 20.0398 18.4004 20.0398C18.9099 20.0398 19.3474 19.9205 19.7129 19.6818C20.0803 19.4413 20.3635 19.0938 20.5623 18.6392C20.7612 18.1847 20.8606 17.6373 20.8606 16.9972C20.8625 16.3608 20.764 15.8192 20.5652 15.3722C20.3663 14.9252 20.0822 14.5853 19.7129 14.3523C19.3455 14.1175 18.908 14 18.4004 14C17.8928 14 17.4553 14.1175 17.0879 14.3523C16.7224 14.5853 16.4402 14.9252 16.2413 15.3722C16.0443 15.8173 15.9449 16.3589 15.943 16.9972C15.9411 17.6354 16.0396 18.1818 16.2385 18.6364C16.4373 19.089 16.7205 19.4366 17.0879 19.679ZM19.1362 18.4262C18.9487 18.7349 18.7034 18.8892 18.4004 18.8892C18.1996 18.8892 18.0226 18.8211 17.8691 18.6847C17.7157 18.5464 17.5964 18.3372 17.5112 18.0568C17.4279 17.7765 17.3871 17.4233 17.389 16.9972C17.3909 16.3684 17.4847 15.9025 17.6703 15.5995C17.8559 15.2945 18.0993 15.1421 18.4004 15.1421C18.603 15.1421 18.7801 15.2093 18.9316 15.3438C19.0832 15.4782 19.2015 15.6828 19.2868 15.9574C19.372 16.2301 19.4146 16.5767 19.4146 16.9972C19.4165 17.6392 19.3237 18.1156 19.1362 18.4262Z",
+        fill,
+        fillRule: "evenodd"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M13.7746 19.8978C13.8482 19.8978 13.9079 19.8381 13.9079 19.7644V14.2129C13.9079 14.1393 13.8482 14.0796 13.7746 14.0796H12.642C12.6171 14.0796 12.5927 14.0865 12.5716 14.0997L11.2322 14.9325C11.1931 14.9568 11.1693 14.9996 11.1693 15.0457V15.9497C11.1693 16.0539 11.2833 16.1178 11.3722 16.0635L12.464 15.396C12.4682 15.3934 12.473 15.3921 12.4779 15.3921C12.4926 15.3921 12.5045 15.404 12.5045 15.4187V19.7644C12.5045 19.8381 12.5642 19.8978 12.6378 19.8978H13.7746Z",
+        fill
+      }
+    )
+  ] });
+}
+function EmbedMediaIconSeekForward10(props) {
+  const fill = props.color;
+  return /* @__PURE__ */ jsxRuntime.jsxs(IconShell, { size: props.size, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M15.3333 10.3452C15.3333 10.8924 15.9561 11.2066 16.3962 10.8814L20.9234 7.5364C21.2841 7.26993 21.2841 6.73054 20.9235 6.46405L16.3962 3.11873C15.9561 2.79356 15.3333 3.10773 15.3333 3.6549V5.22682C15.3333 5.29746 15.2778 5.35579 15.2073 5.36066C9.31791 5.76757 4.66667 10.674 4.66667 16.6667C4.66667 22.9259 9.74078 28 16 28C22.0352 28 26.9686 23.2827 27.314 17.3341C27.3354 16.9665 27.0348 16.6673 26.6666 16.6673H24.6666C24.2984 16.6673 24.0029 16.9668 23.9726 17.3337C23.6336 21.4399 20.1937 24.6667 16 24.6667C11.5817 24.6667 8 21.085 8 16.6667C8 12.5225 11.1517 9.11428 15.1887 8.70739C15.2663 8.69957 15.3333 8.76096 15.3333 8.83893V10.3452Z",
+        fill
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        clipRule: "evenodd",
+        d: "M17.0879 19.679C17.4553 19.9195 17.8928 20.0398 18.4004 20.0398C18.9099 20.0398 19.3474 19.9205 19.7129 19.6818C20.0803 19.4413 20.3635 19.0938 20.5623 18.6392C20.7612 18.1847 20.8606 17.6373 20.8606 16.9972C20.8625 16.3608 20.764 15.8192 20.5652 15.3722C20.3663 14.9252 20.0822 14.5853 19.7129 14.3523C19.3455 14.1175 18.908 14 18.4004 14C17.8928 14 17.4553 14.1175 17.0879 14.3523C16.7224 14.5853 16.4402 14.9252 16.2413 15.3722C16.0443 15.8173 15.9449 16.3589 15.943 16.9972C15.9411 17.6354 16.0396 18.1818 16.2385 18.6364C16.4373 19.089 16.7205 19.4366 17.0879 19.679ZM19.1362 18.4262C18.9487 18.7349 18.7034 18.8892 18.4004 18.8892C18.1996 18.8892 18.0225 18.8211 17.8691 18.6847C17.7157 18.5464 17.5964 18.3372 17.5112 18.0568C17.4278 17.7765 17.3871 17.4233 17.389 16.9972C17.3909 16.3684 17.4847 15.9025 17.6703 15.5995C17.8559 15.2945 18.0992 15.1421 18.4004 15.1421C18.603 15.1421 18.7801 15.2093 18.9316 15.3438C19.0831 15.4782 19.2015 15.6828 19.2867 15.9574C19.372 16.2301 19.4146 16.5767 19.4146 16.9972C19.4165 17.6392 19.3237 18.1156 19.1362 18.4262Z",
+        fill,
+        fillRule: "evenodd"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M13.7746 19.8978C13.8482 19.8978 13.9079 19.8381 13.9079 19.7644V14.2129C13.9079 14.1393 13.8482 14.0796 13.7746 14.0796H12.642C12.6171 14.0796 12.5927 14.0865 12.5716 14.0997L11.2322 14.9325C11.1931 14.9568 11.1693 14.9996 11.1693 15.0457V15.9497C11.1693 16.0539 11.2833 16.1178 11.3722 16.0635L12.464 15.396C12.4682 15.3934 12.473 15.3921 12.4779 15.3921C12.4926 15.3921 12.5045 15.404 12.5045 15.4187V19.7644C12.5045 19.8381 12.5642 19.8978 12.6378 19.8978H13.7746Z",
+        fill
+      }
+    )
+  ] });
+}
+function EmbedMediaIconFullscreen(props) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(IconShell, { size: props.size, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M25.3299 7.26517C25.2958 6.929 25.0119 6.66666 24.6667 6.66666H19.3334C18.9652 6.66666 18.6667 6.96514 18.6667 7.33333V9.33333C18.6667 9.70152 18.9652 10 19.3334 10L21.8667 10C21.9403 10 22 10.0597 22 10.1333V12.6667C22 13.0349 22.2985 13.3333 22.6667 13.3333H24.6667C25.0349 13.3333 25.3334 13.0349 25.3334 12.6667V7.33333C25.3334 7.31032 25.3322 7.28758 25.3299 7.26517Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M22 21.8667C22 21.9403 21.9403 22 21.8667 22L19.3334 22C18.9652 22 18.6667 22.2985 18.6667 22.6667V24.6667C18.6667 25.0349 18.9652 25.3333 19.3334 25.3333L24.6667 25.3333C25.0349 25.3333 25.3334 25.0349 25.3334 24.6667V19.3333C25.3334 18.9651 25.0349 18.6667 24.6667 18.6667H22.6667C22.2985 18.6667 22 18.9651 22 19.3333V21.8667Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M12.6667 22H10.1334C10.0597 22 10 21.9403 10 21.8667V19.3333C10 18.9651 9.70154 18.6667 9.33335 18.6667H7.33335C6.96516 18.6667 6.66669 18.9651 6.66669 19.3333V24.6667C6.66669 25.0349 6.96516 25.3333 7.33335 25.3333H12.6667C13.0349 25.3333 13.3334 25.0349 13.3334 24.6667V22.6667C13.3334 22.2985 13.0349 22 12.6667 22Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M10 12.6667V10.1333C10 10.0597 10.0597 10 10.1334 10L12.6667 10C13.0349 10 13.3334 9.70152 13.3334 9.33333V7.33333C13.3334 6.96514 13.0349 6.66666 12.6667 6.66666H7.33335C6.96516 6.66666 6.66669 6.96514 6.66669 7.33333V12.6667C6.66669 13.0349 6.96516 13.3333 7.33335 13.3333H9.33335C9.70154 13.3333 10 13.0349 10 12.6667Z",
+        fill: props.color
+      }
+    )
+  ] });
+}
+function EmbedMediaIconFullscreenExit(props) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(IconShell, { size: props.size, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M19.3334 13.3333C18.9652 13.3333 18.6667 13.0349 18.6667 12.6667L18.6667 7.33333C18.6667 6.96514 18.9652 6.66666 19.3334 6.66666H21.3334C21.7015 6.66666 22 6.96514 22 7.33333V9.86666C22 9.9403 22.0597 10 22.1334 10L24.6667 10C25.0349 10 25.3334 10.2985 25.3334 10.6667V12.6667C25.3334 13.0349 25.0349 13.3333 24.6667 13.3333L19.3334 13.3333Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M13.3334 19.3333C13.3334 18.9651 13.0349 18.6667 12.6667 18.6667H7.33335C6.96516 18.6667 6.66669 18.9651 6.66669 19.3333V21.3333C6.66669 21.7015 6.96516 22 7.33335 22H9.86669C9.94032 22 10 22.0597 10 22.1333L10 24.6667C10 25.0349 10.2985 25.3333 10.6667 25.3333H12.6667C13.0349 25.3333 13.3334 25.0349 13.3334 24.6667L13.3334 19.3333Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M18.6667 24.6667C18.6667 25.0349 18.9652 25.3333 19.3334 25.3333H21.3334C21.7015 25.3333 22 25.0349 22 24.6667V22.1333C22 22.0597 22.0597 22 22.1334 22H24.6667C25.0349 22 25.3334 21.7015 25.3334 21.3333V19.3333C25.3334 18.9651 25.0349 18.6667 24.6667 18.6667L19.3334 18.6667C18.9652 18.6667 18.6667 18.9651 18.6667 19.3333L18.6667 24.6667Z",
+        fill: props.color
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Path,
+      {
+        d: "M10.6667 13.3333H12.6667C13.0349 13.3333 13.3334 13.0349 13.3334 12.6667L13.3334 10.6667V7.33333C13.3334 6.96514 13.0349 6.66666 12.6667 6.66666H10.6667C10.2985 6.66666 10 6.96514 10 7.33333L10 9.86666C10 9.9403 9.94033 10 9.86669 10L7.33335 10C6.96516 10 6.66669 10.2985 6.66669 10.6667V12.6667C6.66669 13.0349 6.96516 13.3333 7.33335 13.3333L10.6667 13.3333Z",
+        fill: props.color
+      }
+    )
+  ] });
+}
+function EmbedMediaIconPictureInPicture(props) {
+  const pixels = props.size ?? 22;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    jsx_native_bridge_default,
+    {
+      accessibilityElementsHidden: true,
+      height: pixels,
+      importantForAccessibility: "no",
+      viewBox: "0 0 24 24",
+      width: pixels,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Path,
+        {
+          d: "M19 7h-8v6h8V7zm0-2c1.1 0 2 .9 2 2v6c0 1.1-.9 2-2 2h-8c-1.1 0-2-.9-2-2V7c0-1.1.9-2 2-2h8zM5 5v14h14v-2H7V5H5z",
+          fill: props.color
+        }
+      )
+    }
+  );
+}
+function EmbedMediaIconCast(props) {
+  const pixels = props.size ?? 22;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    jsx_native_bridge_default,
+    {
+      accessibilityElementsHidden: true,
+      height: pixels,
+      importantForAccessibility: "no",
+      viewBox: "0 0 24 24",
+      width: pixels,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Path,
+        {
+          d: "M21 3H3c-1.1 0-2 .9-2 2v3h2V5h18v14h-7v2h7c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM1 18v3h3c0-1.66-1.34-3-3-3zm0-4v2c2.76 0 5 2.24 5 5h2c0-3.87-3.13-7-7-7zm0-4v2c4.97 0 9 4.03 9 9h2c0-6.08-4.93-11-11-11z",
+          fill: props.color
+        }
+      )
+    }
+  );
+}
+function EmbedMediaIconCastConnected(props) {
+  const pixels = props.size ?? 22;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    jsx_native_bridge_default,
+    {
+      accessibilityElementsHidden: true,
+      height: pixels,
+      importantForAccessibility: "no",
+      viewBox: "0 0 24 24",
+      width: pixels,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Path,
+        {
+          d: "M1 18v3h3c0-1.66-1.34-3-3-3zm0-4v2c2.76 0 5 2.24 5 5h2c0-3.87-3.13-7-7-7zm18-7H5v1.63c3.96 1.28 7.09 4.41 8.37 8.37H19V7zM1 10v2c4.97 0 9 4.03 9 9h2c0-6.08-4.93-11-11-11zm20-7H3c-1.1 0-2 .9-2 2v3h2V5h18v14h-7v2h7c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z",
+          fill: props.color
+        }
+      )
+    }
+  );
+}
+
+// src/lib/build-moviie-embed-brand-home-url.ts
+function buildMoviieEmbedBrandHomeUrl() {
+  const url = new URL(`${MOVIIE_BRANDING_MARKETING_ORIGIN}/`);
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_SOURCE, MOVIIE_EMBED_BRAND_UTM.SOURCE);
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_MEDIUM, MOVIIE_EMBED_BRAND_UTM.MEDIUM);
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_CAMPAIGN, MOVIIE_EMBED_BRAND_UTM.CAMPAIGN);
+  return url.toString();
+}
+
+// src/lib/resolve-moviie-skin-layout-scale.ts
+function clampBetween(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function resolveMoviieSkinLayoutScale(windowWidth) {
+  if (!Number.isFinite(windowWidth) || windowWidth <= 0) {
+    return 1;
+  }
+  const raw = windowWidth / MOVIIE_SKIN_LAYOUT_REFERENCE_WIDTH_PT;
+  return clampBetween(raw, MOVIIE_SKIN_LAYOUT_SCALE_MIN, MOVIIE_SKIN_LAYOUT_SCALE_MAX);
+}
+
+// src/lib/build-moviie-skin-layout-metrics.ts
+function scaleSkinLayoutDp(layoutScale, baseAtReference) {
+  return baseAtReference * layoutScale;
+}
+function buildMoviieSkinLayoutMetrics(windowWidth, options) {
+  const layoutScale = resolveMoviieSkinLayoutScale(windowWidth);
+  const brandMarkWidthPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_BRAND_MARK_TARGET_WIDTH_AT_REFERENCE_PT
+  );
+  const brandMarkHeightPx = brandMarkWidthPx * (MOVIIE_SKIN_BRAND_MARK_ARTBOARD_HEIGHT_PX / MOVIIE_SKIN_BRAND_MARK_ARTBOARD_WIDTH_PX);
+  const timelineThumbDiameterPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_TIMELINE_THUMB_DIAMETER_PX
+  );
+  const timelineBarHeightPx = scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_TIMELINE_BAR_HEIGHT_PX);
+  const timelineThumbBottomInsetPx = timelineBarHeightPx / 2 - timelineThumbDiameterPx / 2;
+  const timelineTouchPaddingVerticalPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_TIMELINE_TOUCH_PADDING_VERTICAL_PX
+  );
+  const fullscreenHudBoostPx = options?.fullscreenHudProtection === true ? scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CUSTOM_FULLSCREEN_HUD_EDGE_BOOST_REFERENCE_PT) : 0;
+  const hudEdgeInsetPx = scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_FLOATING_HUD_EDGE_INSET_PX) + fullscreenHudBoostPx;
+  return {
+    layoutScale,
+    brandMarkWidthPx,
+    brandMarkHeightPx,
+    hudEdgeInsetPx,
+    floatingHudAboveTimelineGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_ABOVE_TIMELINE_GAP_AT_REFERENCE_PT
+    ),
+    hudClockCornerRadiusPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_CLOCK_CORNER_RADIUS_PX
+    ),
+    controlIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CONTROL_ICON_PX),
+    seekIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_SEEK_ICON_PX),
+    seekScrimOuterDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_SEEK_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    centerPlayIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CENTER_PLAY_ICON_PX),
+    centerClusterColumnGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_CLUSTER_COLUMN_GAP_PX
+    ),
+    playScrimOuterDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_PLAY_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    clockTextFontSizePx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CLOCK_TEXT_FONT_SIZE_AT_REFERENCE_PT
+    ),
+    timelineThumbDiameterPx,
+    timelineTouchPaddingVerticalPx,
+    timelineBarHeightPx,
+    timelineThumbBottomInsetPx,
+    timelineStackHeightChromeVisiblePx: timelineTouchPaddingVerticalPx + timelineThumbDiameterPx,
+    bufferingIndicatorSlotPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_BUFFERING_INDICATOR_SLOT_PX
+    ),
+    chromeEdgeGradientHeightPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CHROME_EDGE_GRADIENT_HEIGHT_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenScrimDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenIconPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_ICON_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenTopIconPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_TOP_ICON_AT_REFERENCE_PT
+    ),
+    floatingHudButtonGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_BUTTON_GAP_AT_REFERENCE_PT
+    )
+  };
+}
+
+// src/lib/compute-playback-buffering.ts
+var PLAYER_STATUS_LOADING = "loading";
+function computePlaybackBuffering(state) {
+  if (computeMoviiePlaybackEnded({
+    playing: state.playing,
+    currentTime: state.currentTime,
+    duration: state.duration,
+    isLive: state.isLive,
+    loop: state.loop
+  })) {
+    return false;
+  }
+  if (state.status === PLAYER_STATUS_LOADING) {
+    return true;
+  }
+  if (state.playing && Number.isFinite(state.duration) && state.duration > 0 && state.bufferedPosition >= 0 && state.currentTime > 0.08 && state.bufferedPosition < state.currentTime + MOVIIE_SKIN_BUFFER_UNDERRUN_LEAD_SECONDS) {
+    return true;
+  }
+  return false;
+}
+function usePlaybackUiSync(player) {
+  const [snapshot, setSnapshot] = React.useState({
+    bufferedPosition: player.bufferedPosition,
+    currentTime: player.currentTime,
+    duration: player.duration,
+    playing: player.playing,
+    status: player.status
+  });
+  React.useEffect(() => {
+    const subscriptions = [
+      player.addListener("timeUpdate", ({ currentTime }) => {
+        setSnapshot((previous) => ({
+          ...previous,
+          bufferedPosition: player.bufferedPosition,
+          currentTime,
+          duration: player.duration,
+          status: player.status
+        }));
+      }),
+      player.addListener("playingChange", ({ isPlaying }) => {
+        setSnapshot((previous) => ({
+          ...previous,
+          playing: isPlaying,
+          bufferedPosition: player.bufferedPosition,
+          status: player.status
+        }));
+      }),
+      player.addListener("sourceChange", () => {
+        setSnapshot({
+          bufferedPosition: player.bufferedPosition,
+          currentTime: player.currentTime,
+          duration: player.duration,
+          playing: player.playing,
+          status: player.status
+        });
+      }),
+      player.addListener("statusChange", ({ status }) => {
+        setSnapshot((previous) => ({
+          ...previous,
+          bufferedPosition: player.bufferedPosition,
+          status
+        }));
+      }),
+      player.addListener("playToEnd", () => {
+        setSnapshot((previous) => ({
+          ...previous,
+          playing: false,
+          bufferedPosition: player.bufferedPosition,
+          currentTime: player.currentTime,
+          duration: player.duration,
+          status: player.status
+        }));
+      })
+    ];
+    return () => {
+      for (const sub of subscriptions) {
+        sub.remove();
+      }
+    };
+  }, [player]);
+  return snapshot;
+}
+var MoviieSkinChromeContext = React.createContext(
+  null
+);
+function useMoviieSkinChrome() {
+  const ctx = React.useContext(MoviieSkinChromeContext);
+  if (ctx == null) {
+    throw new Error("useMoviieSkinChrome must be used within MoviieSkinChromeProvider");
+  }
+  return ctx;
+}
+function MoviieSkinChromeProvider({
+  children,
+  player,
+  playback,
+  videoViewRef,
+  customFullscreen = false,
+  skinLayoutMetricsWidth,
+  onRequestEnterCustomFullscreen,
+  onRequestExitCustomFullscreenAnimated,
+  autoHideMs: _unusedAutoHideMs,
+  visibleByDefault = true,
+  pictureInPictureControlEnabled = false,
+  pictureInPictureActive = false,
+  togglePictureInPicture: togglePictureInPictureProp,
+  castControlEnabled = false,
+  castConnected = false,
+  openCastPicker: openCastPickerProp
+}) {
+  const noopPictureInPicture = React.useCallback(() => {
+  }, []);
+  const togglePictureInPicture = togglePictureInPictureProp ?? noopPictureInPicture;
+  const noopOpenCastPicker = React.useCallback(() => {
+  }, []);
+  const openCastPicker = openCastPickerProp ?? noopOpenCastPicker;
+  const { width: windowWidth } = reactNative.useWindowDimensions();
+  const layoutBasisWidth = skinLayoutMetricsWidth ?? windowWidth;
+  const layout = React.useMemo(
+    () => buildMoviieSkinLayoutMetrics(layoutBasisWidth, {
+      fullscreenHudProtection: customFullscreen
+    }),
+    [customFullscreen, layoutBasisWidth]
+  );
+  const ui = usePlaybackUiSync(player);
+  const [chromeVisible, setChromeVisible] = React.useState(visibleByDefault);
+  const [timelineScrubClockSeconds, setTimelineScrubClockSeconds] = React.useState(null);
+  const playbackEndedForChrome = React.useMemo(
+    () => computeMoviiePlaybackEnded({
+      playing: ui.playing,
+      currentTime: ui.currentTime,
+      duration: ui.duration,
+      isLive: player.isLive,
+      loop: player.loop
+    }),
+    [ui.playing, ui.currentTime, ui.duration, player.isLive, player.loop]
+  );
+  React.useEffect(() => {
+    if (playbackEndedForChrome) {
+      setChromeVisible(true);
+    }
+  }, [playbackEndedForChrome]);
+  const chromeOpacity = React.useRef(new reactNative.Animated.Value(visibleByDefault ? 1 : 0)).current;
+  React.useEffect(() => {
+    reactNative.Animated.timing(chromeOpacity, {
+      duration: MOVIIE_SKIN_CONTROLS_FADE_MS,
+      easing: reactNative.Easing.out(reactNative.Easing.quad),
+      toValue: chromeVisible ? 1 : 0,
+      useNativeDriver: true
+    }).start();
+  }, [chromeOpacity, chromeVisible]);
+  const bumpChromeInteraction = React.useCallback(() => {
+    setChromeVisible(true);
+  }, []);
+  const dismissChrome = React.useCallback(() => {
+    setChromeVisible(false);
+  }, []);
+  const togglePlay = React.useCallback(() => {
+    if (player.playing) {
+      player.pause();
+      return;
+    }
+    if (computeMoviiePlaybackEnded({
+      playing: false,
+      currentTime: player.currentTime,
+      duration: player.duration,
+      isLive: player.isLive,
+      loop: player.loop
+    })) {
+      player.currentTime = 0;
+    }
+    player.play();
+    setChromeVisible(false);
+  }, [player]);
+  const seekBack = React.useCallback(() => {
+    void player.seekBy(-MOVIIE_SKIN_SEEK_JUMP_SECONDS);
+    setChromeVisible(false);
+  }, [player]);
+  const seekForward = React.useCallback(() => {
+    void player.seekBy(MOVIIE_SKIN_SEEK_JUMP_SECONDS);
+    setChromeVisible(false);
+  }, [player]);
+  const toggleFullscreen = React.useCallback(() => {
+    if (customFullscreen) {
+      onRequestExitCustomFullscreenAnimated?.();
+      return;
+    }
+    setChromeVisible(false);
+    if (onRequestEnterCustomFullscreen != null) {
+      onRequestEnterCustomFullscreen();
+      return;
+    }
+    void videoViewRef.current?.enterFullscreen?.().catch(() => void 0);
+  }, [
+    customFullscreen,
+    onRequestEnterCustomFullscreen,
+    onRequestExitCustomFullscreenAnimated,
+    videoViewRef
+  ]);
+  const isBuffering = React.useMemo(
+    () => computePlaybackBuffering({
+      ...ui,
+      isLive: player.isLive,
+      loop: player.loop
+    }),
+    [ui, player.isLive, player.loop]
+  );
+  const value = React.useMemo(
+    () => ({
+      playback,
+      player,
+      videoViewRef,
+      chromeVisible,
+      chromeOpacity,
+      timelineScrubClockSeconds,
+      setTimelineScrubClockSeconds,
+      bumpChromeInteraction,
+      dismissChrome,
+      ui,
+      isBuffering,
+      layout,
+      togglePlay,
+      seekBack,
+      seekForward,
+      toggleFullscreen,
+      isCustomFullscreen: customFullscreen,
+      pictureInPictureActive,
+      pictureInPictureControlEnabled,
+      togglePictureInPicture,
+      castControlEnabled,
+      castConnected,
+      openCastPicker
+    }),
+    [
+      playback,
+      player,
+      videoViewRef,
+      chromeVisible,
+      chromeOpacity,
+      timelineScrubClockSeconds,
+      setTimelineScrubClockSeconds,
+      bumpChromeInteraction,
+      dismissChrome,
+      ui,
+      isBuffering,
+      layout,
+      togglePlay,
+      seekBack,
+      seekForward,
+      toggleFullscreen,
+      customFullscreen,
+      pictureInPictureActive,
+      pictureInPictureControlEnabled,
+      togglePictureInPicture,
+      castControlEnabled,
+      castConnected,
+      openCastPicker
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinChromeContext.Provider, { value, children });
+}
+function MoviieEmbedBrandMark() {
+  const { layout } = useMoviieSkinChrome();
+  const fg = MOVIIE_SKIN_CHROME_FOREGROUND_HEX;
+  const openMarketingSite = React.useCallback(() => {
+    void reactNative.Linking.openURL(buildMoviieEmbedBrandHomeUrl());
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityHint: "Abre o site da Moviie no navegador",
+      accessibilityLabel: "Moviie \u2014 p\xE1gina inicial",
+      accessibilityRole: "link",
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: openMarketingSite,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        jsx_native_bridge_default,
+        {
+          accessibilityElementsHidden: true,
+          height: layout.brandMarkHeightPx,
+          importantForAccessibility: "no",
+          viewBox: MOVIIE_EMBED_BRAND_VIEW_BOX,
+          width: layout.brandMarkWidthPx,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              Path,
+              {
+                d: "M6.066 43.725H0V0h6.066L21.8 36.77 37.533 0h6.192v43.725H37.66V26.43c0-8.165.063-11.128.38-14.212L24.706 43.725h-5.813L5.623 12.337c.317 2.117.443 6.593.443 12.7z",
+                fill: fg
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              Path,
+              {
+                d: "M47.527 29.467c0-9.494 6.454-16.16 15.239-16.16 8.725 0 15.179 6.666 15.179 16.16s-6.454 16.16-15.179 16.16c-8.785 0-15.239-6.666-15.239-16.16m5.678 0c0 6.413 3.884 10.878 9.561 10.878 5.617 0 9.562-4.465 9.562-10.878S68.383 18.59 62.766 18.59c-5.677 0-9.561 4.465-9.561 10.878M159.227 45.626c-8.737 0-14.744-6.526-14.744-16.065 0-9.601 5.886-16.253 14.501-16.253 8.434 0 13.955 6.024 13.955 15.124v2.196l-22.934.063c.424 6.464 3.701 10.04 9.343 10.04 4.43 0 7.342-1.882 8.313-5.396H173c-1.456 6.589-6.431 10.291-13.773 10.291m-.243-27.36c-4.975 0-8.13 3.074-8.858 8.471h17.11c0-5.083-3.216-8.472-8.252-8.472",
+                fill: fg
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              Path,
+              {
+                d: "m140.681 15.209-12.313 28.516h-4.794l12.313-28.516zm-14.384 0-12.312 28.516h-4.811l12.313-28.516zm-39.363 0 6.553 16.138c1.06 2.768 1.927 5.221 2.42 7.006l.944-.007c.49-1.892 1.476-4.393 2.539-6.988l6.68-16.15h5.054L98.799 43.726h-5.15L81.747 15.21z",
+                fill: "none",
+                stroke: fg,
+                strokeLinejoin: "bevel",
+                strokeWidth: MOVIIE_EMBED_BRAND_LETTERMARK_STROKE_WIDTH
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+}
+function pressOpacity(pressed) {
+  return {
+    opacity: pressed ? MOVIIE_SKIN_CHROME_CONTROL_PRESSED_OPACITY : MOVIIE_SKIN_CHROME_CONTROL_REST_OPACITY
+  };
+}
+function ScrimPad(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: "button",
+      accessibilityState: { selected: props.selected },
+      hitSlop: props.hitSlop,
+      onPress: props.onPress,
+      style: (state) => [props.chromeScrimBaseStyle, props.style, pressOpacity(state.pressed)],
+      children: props.children
+    }
+  );
+}
+function MoviieSkinCastCircleButton(props) {
+  const Icon = props.castConnected ? EmbedMediaIconCastConnected : EmbedMediaIconCast;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ScrimPad,
+    {
+      accessibilityLabel: props.castConnected ? "Encerrar transmiss\xE3o" : "Transmitir",
+      chromeScrimBaseStyle: props.chromeScrimBaseStyle,
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      selected: props.castConnected,
+      style: props.circleScrimStyle,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Icon,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenIconPx
+        }
+      )
+    }
+  );
+}
+function MoviieSkinCastTopBareButton(props) {
+  const Icon = props.castConnected ? EmbedMediaIconCastConnected : EmbedMediaIconCast;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityLabel: props.castConnected ? "Encerrar transmiss\xE3o" : "Transmitir",
+      accessibilityRole: "button",
+      accessibilityState: { selected: props.castConnected },
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      style: (state) => pressOpacity(state.pressed),
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { children: /* @__PURE__ */ jsxRuntime.jsx(
+        Icon,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenTopIconPx * MOVIIE_SKIN_TOP_ICON_CAST_VISUAL_SCALE
+        }
+      ) })
+    }
+  );
+}
+function MoviieSkinChromeEdgeGradients(props) {
+  const [hostWidth, setHostWidth] = React.useState(0);
+  const [hostHeight, setHostHeight] = React.useState(0);
+  const onHostLayout = React.useCallback((event) => {
+    const { height, width } = event.nativeEvent.layout;
+    setHostWidth(width);
+    setHostHeight(height);
+  }, []);
+  const rawTopPx = props.layout.chromeEdgeGradientHeightPx;
+  const rawBottomPx = props.layout.chromeEdgeGradientHeightPx + (props.showProgress ? props.layout.timelineStackHeightChromeVisiblePx : 0);
+  const { effBottomPx, effTopPx, svgWidthPx } = React.useMemo(() => {
+    if (hostWidth <= 0 || hostHeight <= 0) {
+      return { effBottomPx: 0, effTopPx: 0, svgWidthPx: 0 };
+    }
+    const svgWidthPx2 = hostWidth;
+    const maxTotalPx = Math.max(
+      0,
+      hostHeight - MOVIIE_SKIN_CHROME_EDGE_GRADIENT_MIN_CLEAR_MIDDLE_PX
+    );
+    const rawSum = rawTopPx + rawBottomPx;
+    const scale = rawSum > maxTotalPx && maxTotalPx > 0 && rawSum > 0 ? maxTotalPx / rawSum : 1;
+    return {
+      effBottomPx: rawBottomPx * scale,
+      effTopPx: rawTopPx * scale,
+      svgWidthPx: svgWidthPx2
+    };
+  }, [hostHeight, hostWidth, rawBottomPx, rawTopPx]);
+  const topFillUrl = `url(#${MOVIIE_SKIN_CHROME_SVG_GRADIENT_TOP_EDGE_ID})`;
+  const bottomFillUrl = `url(#${MOVIIE_SKIN_CHROME_SVG_GRADIENT_BOTTOM_EDGE_ID})`;
+  const layoutReady = hostWidth > 0 && hostHeight > 0 && svgWidthPx > 0;
+  const fadeEndOffset = String(MOVIIE_SKIN_CHROME_EDGE_GRADIENT_EDGE_SOLID_FADE_END_FRACTION);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      accessibilityElementsHidden: true,
+      importantForAccessibility: "no-hide-descendants",
+      onLayout: onHostLayout,
+      pointerEvents: "none",
+      style: reactNative.StyleSheet.absoluteFillObject,
+      testID: "moviie-chrome-edge-gradients",
+      children: [
+        layoutReady && effTopPx > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.View,
+          {
+            accessibilityElementsHidden: true,
+            importantForAccessibility: "no-hide-descendants",
+            pointerEvents: "none",
+            style: {
+              height: effTopPx,
+              left: 0,
+              overflow: "hidden",
+              position: "absolute",
+              top: 0,
+              width: hostWidth
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsxs(jsx_native_bridge_default, { accessibilityElementsHidden: true, height: effTopPx, width: svgWidthPx, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(Defs, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+                LinearGradient,
+                {
+                  gradientUnits: "objectBoundingBox",
+                  id: MOVIIE_SKIN_CHROME_SVG_GRADIENT_TOP_EDGE_ID,
+                  x1: "0",
+                  x2: "0",
+                  y1: "0",
+                  y2: "1",
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      Stop,
+                      {
+                        offset: "0",
+                        stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX,
+                        stopOpacity: MOVIIE_SKIN_CHROME_GRADIENT_EDGE_ALPHA
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      Stop,
+                      {
+                        offset: fadeEndOffset,
+                        stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX,
+                        stopOpacity: 0
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(Stop, { offset: "1", stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX, stopOpacity: 0 })
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(Rect, { fill: topFillUrl, height: effTopPx, width: svgWidthPx })
+            ] })
+          }
+        ) : null,
+        layoutReady && effBottomPx > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.View,
+          {
+            accessibilityElementsHidden: true,
+            importantForAccessibility: "no-hide-descendants",
+            pointerEvents: "none",
+            style: {
+              bottom: 0,
+              height: effBottomPx,
+              left: 0,
+              overflow: "hidden",
+              position: "absolute",
+              width: hostWidth
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsxs(jsx_native_bridge_default, { accessibilityElementsHidden: true, height: effBottomPx, width: svgWidthPx, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(Defs, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+                LinearGradient,
+                {
+                  gradientUnits: "objectBoundingBox",
+                  id: MOVIIE_SKIN_CHROME_SVG_GRADIENT_BOTTOM_EDGE_ID,
+                  x1: "0",
+                  x2: "0",
+                  y1: "1",
+                  y2: "0",
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      Stop,
+                      {
+                        offset: "0",
+                        stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX,
+                        stopOpacity: MOVIIE_SKIN_CHROME_GRADIENT_EDGE_ALPHA
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      Stop,
+                      {
+                        offset: fadeEndOffset,
+                        stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX,
+                        stopOpacity: 0
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(Stop, { offset: "1", stopColor: MOVIIE_SKIN_CHROME_GRADIENT_BLACK_HEX, stopOpacity: 0 })
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(Rect, { fill: bottomFillUrl, height: effBottomPx, width: svgWidthPx })
+            ] })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/lib/clamp-unit-interval.ts
+function clampUnitInterval(value) {
+  return Math.min(1, Math.max(0, value));
+}
+
+// src/lib/compute-playback-progress-ratio.ts
+function computePlaybackProgressRatio(state) {
+  if (!state.durationOk || !Number.isFinite(state.currentTime) || !Number.isFinite(state.duration) || state.duration <= 0) {
+    return 0;
+  }
+  const raw = state.currentTime / state.duration;
+  if (raw >= 1) {
+    return 1;
+  }
+  const snapToEndWhilePaused = !state.playing && state.currentTime >= state.duration - MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS;
+  const ratio = snapToEndWhilePaused ? 1 : raw;
+  return clampUnitInterval(ratio);
+}
+
+// src/lib/compute-timeline-scrub-commit-time.ts
+function computeTimelineScrubCommitTime(params) {
+  const {
+    ratio,
+    durationSeconds,
+    chapters,
+    snapThresholdSeconds = MOVIIE_SKIN_TIMELINE_CHAPTER_SNAP_THRESHOLD_SECONDS
+  } = params;
+  const rawTime = ratio * durationSeconds;
+  let nearest = null;
+  let nearestDist = Infinity;
+  for (const chapter of chapters) {
+    const dist = Math.abs(chapter.startTimeSeconds - rawTime);
+    if (dist < nearestDist) {
+      nearestDist = dist;
+      nearest = chapter.startTimeSeconds;
+    }
+  }
+  return nearest !== null && nearestDist <= snapThresholdSeconds ? nearest : rawTime;
+}
+
+// src/lib/resolve-skin-accent-color.ts
+var HEX_COLOR_REGEX = /^#[0-9A-Fa-f]{6}$/;
+function resolveSkinAccentColor(primaryColor) {
+  if (primaryColor != null && HEX_COLOR_REGEX.test(primaryColor)) {
+    return primaryColor;
+  }
+  return MOVIIE_SKIN_DEFAULT_ACCENT_HEX;
+}
+function createMoviieSkinBottomTimelineStyles(layout) {
+  return reactNative.StyleSheet.create({
+    root: {
+      bottom: 0,
+      left: 0,
+      overflow: "visible",
+      pointerEvents: "box-none",
+      position: "absolute",
+      right: 0,
+      zIndex: 24
+    },
+    touchExpansion: {
+      overflow: "visible",
+      paddingBottom: 0,
+      paddingTop: layout.timelineTouchPaddingVerticalPx + MOVIIE_SKIN_TIMELINE_TOUCH_EXPANSION_VERTICAL_DP,
+      position: "relative"
+    },
+    trackStack: {
+      overflow: "visible",
+      width: "100%"
+    },
+    thumbBase: {
+      borderColor: MOVIIE_SKIN_TIMELINE_THUMB_BORDER_RGBA,
+      borderWidth: 1,
+      elevation: 8,
+      position: "absolute",
+      zIndex: 10
+    },
+    unifiedBarSlot: {
+      overflow: "visible",
+      position: "relative",
+      width: "100%"
+    },
+    railLayer: {
+      backgroundColor: MOVIIE_SKIN_TIMELINE_RAIL_BACKGROUND_RGBA,
+      bottom: 0,
+      height: layout.timelineBarHeightPx,
+      left: 0,
+      position: "absolute",
+      right: 0,
+      zIndex: 0
+    },
+    bufferLayer: {
+      backgroundColor: MOVIIE_SKIN_TIMELINE_BUFFER_LAYER_RGBA,
+      bottom: 0,
+      height: layout.timelineBarHeightPx,
+      left: 0,
+      position: "absolute",
+      zIndex: 1
+    },
+    progressLayer: {
+      bottom: 0,
+      height: layout.timelineBarHeightPx,
+      left: 0,
+      position: "absolute",
+      zIndex: 2
+    }
+  });
+}
+function MoviieSkinBottomTimeline() {
+  const {
+    playback,
+    chromeVisible,
+    layout,
+    player,
+    setTimelineScrubClockSeconds,
+    ui
+  } = useMoviieSkinChrome();
+  const styles6 = React.useMemo(
+    () => createMoviieSkinBottomTimelineStyles(layout),
+    [layout]
+  );
+  const { controls } = playback;
+  const accent = resolveSkinAccentColor(playback.branding.primaryColor);
+  const foreground = MOVIIE_SKIN_CHROME_FOREGROUND_HEX;
+  const durationOk = controls.showProgress && Number.isFinite(ui.duration) && ui.duration > 0 && !player.isLive;
+  const progressRatioLive = computePlaybackProgressRatio({
+    currentTime: ui.currentTime,
+    duration: ui.duration,
+    durationOk,
+    playing: ui.playing
+  });
+  const bufferRatioLive = durationOk && Number.isFinite(ui.bufferedPosition) && ui.bufferedPosition >= 0 ? clampUnitInterval(ui.bufferedPosition / ui.duration) : 0;
+  const isDraggingSV = AnimatedReanimated.useSharedValue(false);
+  const awaitingUnlockSV = AnimatedReanimated.useSharedValue(false);
+  const scrubRatioSV = AnimatedReanimated.useSharedValue(0);
+  const progressRatioSV = AnimatedReanimated.useSharedValue(progressRatioLive);
+  const bufferRatioSV = AnimatedReanimated.useSharedValue(bufferRatioLive);
+  const trackWidthSV = AnimatedReanimated.useSharedValue(0);
+  const durationSV = AnimatedReanimated.useSharedValue(ui.duration);
+  const chromeVisibleSV = AnimatedReanimated.useSharedValue(chromeVisible);
+  const timelineAccentEngagedSV = AnimatedReanimated.useSharedValue(false);
+  const thumbBaseDiamSV = AnimatedReanimated.useSharedValue(layout.timelineThumbDiameterPx);
+  const barHeightSV = AnimatedReanimated.useSharedValue(layout.timelineBarHeightPx);
+  const isDraggingRef = React.useRef(false);
+  const shouldResumeRef = React.useRef(false);
+  const progressRatioLiveRef = React.useRef(progressRatioLive);
+  progressRatioLiveRef.current = progressRatioLive;
+  const chaptersRef = React.useRef(playback.chapters);
+  chaptersRef.current = playback.chapters;
+  const chromeVisibleRef = React.useRef(chromeVisible);
+  chromeVisibleRef.current = chromeVisible;
+  React.useEffect(() => {
+    if (!isDraggingRef.current) {
+      progressRatioSV.value = progressRatioLive;
+    }
+  }, [progressRatioLive, progressRatioSV]);
+  React.useEffect(() => {
+    bufferRatioSV.value = bufferRatioLive;
+  }, [bufferRatioLive, bufferRatioSV]);
+  React.useEffect(() => {
+    durationSV.value = ui.duration;
+  }, [ui.duration, durationSV]);
+  React.useEffect(() => {
+    thumbBaseDiamSV.value = layout.timelineThumbDiameterPx;
+    barHeightSV.value = layout.timelineBarHeightPx;
+  }, [
+    layout.timelineThumbDiameterPx,
+    layout.timelineBarHeightPx,
+    thumbBaseDiamSV,
+    barHeightSV
+  ]);
+  React.useEffect(() => {
+    chromeVisibleSV.value = chromeVisible;
+    if (chromeVisible) {
+      timelineAccentEngagedSV.value = false;
+      awaitingUnlockSV.value = false;
+    }
+  }, [
+    chromeVisible,
+    chromeVisibleSV,
+    timelineAccentEngagedSV,
+    awaitingUnlockSV
+  ]);
+  React.useEffect(() => {
+    const sub = player.addListener("statusChange", ({ status }) => {
+      if (shouldResumeRef.current && status === "readyToPlay" && !isDraggingRef.current) {
+        player.play();
+      }
+    });
+    return () => sub.remove();
+  }, [player]);
+  React.useEffect(() => {
+    const sub = player.addListener("playingChange", ({ isPlaying }) => {
+      if (isPlaying && !isDraggingRef.current) {
+        shouldResumeRef.current = false;
+      }
+    });
+    return () => sub.remove();
+  }, [player]);
+  const effectiveRatioSV = AnimatedReanimated.useDerivedValue(
+    () => isDraggingSV.value ? scrubRatioSV.value : progressRatioSV.value
+  );
+  const showAccentSV = AnimatedReanimated.useDerivedValue(
+    () => chromeVisibleSV.value || isDraggingSV.value || timelineAccentEngagedSV.value
+  );
+  const showThumbSV = AnimatedReanimated.useDerivedValue(
+    () => chromeVisibleSV.value || isDraggingSV.value || timelineAccentEngagedSV.value
+  );
+  const thumbDiamSV = AnimatedReanimated.useDerivedValue(
+    () => isDraggingSV.value ? Math.round(
+      thumbBaseDiamSV.value * MOVIIE_SKIN_TIMELINE_THUMB_DRAG_DIAMETER_MULTIPLIER
+    ) : thumbBaseDiamSV.value
+  );
+  const progressBarStyle = AnimatedReanimated.useAnimatedStyle(() => ({
+    backgroundColor: showAccentSV.value ? accent : foreground,
+    width: `${effectiveRatioSV.value * 100}%`
+  }));
+  const bufferBarStyle = AnimatedReanimated.useAnimatedStyle(() => ({
+    width: `${bufferRatioSV.value * 100}%`
+  }));
+  const thumbStyle = AnimatedReanimated.useAnimatedStyle(() => {
+    if (!showThumbSV.value) {
+      return { opacity: 0 };
+    }
+    const diameter = thumbDiamSV.value;
+    const radius = diameter / 2;
+    const w = trackWidthSV.value;
+    const left = w > 0 ? Math.min(w - diameter, Math.max(0, effectiveRatioSV.value * w - radius)) : 0;
+    const bh = barHeightSV.value;
+    return {
+      opacity: 1,
+      backgroundColor: showAccentSV.value ? accent : foreground,
+      left,
+      width: diameter,
+      height: diameter,
+      borderRadius: radius,
+      bottom: bh / 2 - radius
+    };
+  });
+  const onScrubBegin = React.useCallback(() => {
+    isDraggingRef.current = true;
+    if (!shouldResumeRef.current) {
+      shouldResumeRef.current = player.playing;
+    }
+  }, [player]);
+  const onScrubUpdate = React.useCallback(
+    (ratio) => {
+      setTimelineScrubClockSeconds(ratio * durationSV.value);
+    },
+    [setTimelineScrubClockSeconds, durationSV]
+  );
+  const onScrubCommit = React.useCallback(
+    (ratio) => {
+      isDraggingRef.current = false;
+      setTimelineScrubClockSeconds(null);
+      const dur = durationSV.value;
+      if (!Number.isFinite(dur) || dur <= 0) return;
+      const targetTime = computeTimelineScrubCommitTime({
+        ratio,
+        durationSeconds: dur,
+        chapters: chaptersRef.current
+      });
+      player.currentTime = targetTime;
+      if (shouldResumeRef.current) {
+        player.play();
+      }
+    },
+    [setTimelineScrubClockSeconds, player, durationSV]
+  );
+  const onScrubCancel = React.useCallback(() => {
+    isDraggingRef.current = false;
+    setTimelineScrubClockSeconds(null);
+    progressRatioSV.value = progressRatioLiveRef.current;
+  }, [setTimelineScrubClockSeconds, progressRatioSV]);
+  const onAccentEngage = React.useCallback(() => {
+    timelineAccentEngagedSV.value = true;
+  }, [timelineAccentEngagedSV]);
+  const onAccentDisengageCancel = React.useCallback(() => {
+    timelineAccentEngagedSV.value = false;
+  }, [timelineAccentEngagedSV]);
+  const panGesture = React.useMemo(
+    () => reactNativeGestureHandler.Gesture.Pan().activeOffsetX([-8, 8]).failOffsetY([-15, 15]).enabled(durationOk).onBegin(() => {
+      "worklet";
+      if (!chromeVisibleSV.value && !timelineAccentEngagedSV.value) {
+        awaitingUnlockSV.value = true;
+        AnimatedReanimated.runOnJS(onAccentEngage)();
+      }
+    }).onStart((e) => {
+      "worklet";
+      if (awaitingUnlockSV.value) {
+        return;
+      }
+      isDraggingSV.value = true;
+      AnimatedReanimated.runOnJS(onScrubBegin)();
+      const w = trackWidthSV.value;
+      if (w <= 0) return;
+      const ratio = Math.max(0, Math.min(1, e.x / w));
+      scrubRatioSV.value = ratio;
+      AnimatedReanimated.runOnJS(onScrubUpdate)(ratio);
+    }).onUpdate((e) => {
+      "worklet";
+      const w = trackWidthSV.value;
+      if (w <= 0) return;
+      const ratio = Math.max(0, Math.min(1, e.x / w));
+      if (awaitingUnlockSV.value) {
+        awaitingUnlockSV.value = false;
+        isDraggingSV.value = true;
+        AnimatedReanimated.runOnJS(onScrubBegin)();
+      }
+      if (!isDraggingSV.value) return;
+      scrubRatioSV.value = ratio;
+      AnimatedReanimated.runOnJS(onScrubUpdate)(ratio);
+    }).onEnd(() => {
+      "worklet";
+      if (awaitingUnlockSV.value) {
+        awaitingUnlockSV.value = false;
+        AnimatedReanimated.runOnJS(onAccentDisengageCancel)();
+        return;
+      }
+      if (!isDraggingSV.value) return;
+      const committed = scrubRatioSV.value;
+      progressRatioSV.value = committed;
+      isDraggingSV.value = false;
+      scrubRatioSV.value = 0;
+      AnimatedReanimated.runOnJS(onScrubCommit)(committed);
+    }).onFinalize(() => {
+      "worklet";
+      if (awaitingUnlockSV.value) {
+        awaitingUnlockSV.value = false;
+        AnimatedReanimated.runOnJS(onAccentDisengageCancel)();
+        return;
+      }
+      if (isDraggingSV.value) {
+        isDraggingSV.value = false;
+        scrubRatioSV.value = 0;
+        AnimatedReanimated.runOnJS(onScrubCancel)();
+      }
+    }),
+    [
+      durationOk,
+      isDraggingSV,
+      awaitingUnlockSV,
+      scrubRatioSV,
+      progressRatioSV,
+      trackWidthSV,
+      chromeVisibleSV,
+      timelineAccentEngagedSV,
+      onAccentEngage,
+      onAccentDisengageCancel,
+      onScrubBegin,
+      onScrubUpdate,
+      onScrubCommit,
+      onScrubCancel
+    ]
+  );
+  const onTrackLayout = React.useCallback(
+    (event) => {
+      trackWidthSV.value = event.nativeEvent.layout.width;
+    },
+    [trackWidthSV]
+  );
+  if (!durationOk) {
+    return null;
+  }
+  const unifiedSlotHeightPx = Math.max(
+    layout.timelineThumbDiameterPx,
+    Math.round(
+      layout.timelineThumbDiameterPx * MOVIIE_SKIN_TIMELINE_THUMB_DRAG_DIAMETER_MULTIPLIER
+    )
+  );
+  const scrubHitSlop = {
+    top: MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_TOP_DP,
+    bottom: MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_BOTTOM_DP,
+    left: MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_HORIZONTAL_DP,
+    right: MOVIIE_SKIN_TIMELINE_SCRUB_HIT_SLOP_HORIZONTAL_DP
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { pointerEvents: "box-none", style: styles6.root, children: /* @__PURE__ */ jsxRuntime.jsx(reactNativeGestureHandler.GestureDetector, { gesture: panGesture, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { hitSlop: scrubHitSlop, pointerEvents: "auto", style: styles6.touchExpansion, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles6.trackStack, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      accessibilityRole: "progressbar",
+      accessibilityValue: {
+        max: 1,
+        min: 0,
+        now: progressRatioLive
+      },
+      collapsable: false,
+      style: [styles6.unifiedBarSlot, { height: unifiedSlotHeightPx }],
+      onLayout: onTrackLayout,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles6.railLayer }),
+        /* @__PURE__ */ jsxRuntime.jsx(ReanimatedView, { style: [styles6.bufferLayer, bufferBarStyle] }),
+        /* @__PURE__ */ jsxRuntime.jsx(ReanimatedView, { style: [styles6.progressLayer, progressBarStyle] }),
+        /* @__PURE__ */ jsxRuntime.jsx(ReanimatedView, { style: [styles6.thumbBase, thumbStyle] })
+      ]
+    }
+  ) }) }) }) });
+}
+
+// src/lib/map-smart-progress-display-ratio.ts
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function mapSmartProgressRawRatio(realUnitInterval) {
+  const r = Math.min(1, Math.max(0, realUnitInterval));
+  const {
+    R1,
+    P1,
+    R2,
+    P2,
+    P_MAX_BEFORE_END: pMax
+  } = MOVIIE_SMART_PROGRESS_CONFIG;
+  if (r <= 0) {
+    return 0;
+  }
+  if (r >= 1) {
+    return pMax;
+  }
+  if (r <= R1) {
+    return P1 * easeOutQuad(r / R1);
+  }
+  if (r <= R2) {
+    const t2 = (r - R1) / (R2 - R1);
+    return P1 + (P2 - P1) * t2;
+  }
+  const t = (r - R2) / (1 - R2);
+  return P2 + (pMax - P2) * easeInQuad(t);
+}
+var styles = reactNative.StyleSheet.create({
+  container: {
+    bottom: 0,
+    height: MOVIIE_SMART_PROGRESS_BAR_HEIGHT_DP,
+    left: 0,
+    overflow: "hidden",
+    position: "absolute",
+    right: 0,
+    zIndex: MOVIIE_SMART_PROGRESS_Z_INDEX
+  },
+  fill: {
+    bottom: 0,
+    height: "100%",
+    left: 0,
+    position: "absolute",
+    top: 0
+  }
+});
+function MoviieSkinSmartProgress() {
+  const { playback, player, timelineScrubClockSeconds, ui } = useMoviieSkinChrome();
+  const accent = resolveSkinAccentColor(playback.branding.primaryColor);
+  const durationOk = playback.smartProgressEnabled && Number.isFinite(ui.duration) && ui.duration > 0 && !player.isLive;
+  const [barVisible, setBarVisible] = React.useState(() => !player.muted);
+  const hasUserInteractedRef = React.useRef(!player.muted);
+  const lastDisplayedRef = React.useRef(0);
+  const progressAnim = React.useRef(new reactNative.Animated.Value(0)).current;
+  const syncMutedVisibility = React.useCallback(() => {
+    const muted = player.muted;
+    if (!muted) {
+      hasUserInteractedRef.current = true;
+      setBarVisible(true);
+      return;
+    }
+    if (!hasUserInteractedRef.current) {
+      setBarVisible(false);
+    }
+  }, [player]);
+  React.useEffect(() => {
+    syncMutedVisibility();
+    const subMuted = player.addListener("mutedChange", syncMutedVisibility);
+    const subVolume = player.addListener("volumeChange", syncMutedVisibility);
+    return () => {
+      subMuted.remove();
+      subVolume.remove();
+    };
+  }, [player, syncMutedVisibility]);
+  React.useEffect(() => {
+    lastDisplayedRef.current = 0;
+    progressAnim.setValue(0);
+  }, [playback.embedId, progressAnim]);
+  React.useEffect(() => {
+    if (!durationOk || !barVisible) {
+      return;
+    }
+    const scrubbing = timelineScrubClockSeconds != null;
+    const clockSeconds = scrubbing ? timelineScrubClockSeconds : ui.currentTime;
+    const realRatio = computePlaybackProgressRatio({
+      currentTime: clockSeconds,
+      duration: ui.duration,
+      durationOk: true,
+      playing: ui.playing
+    });
+    const mapped = mapSmartProgressRawRatio(realRatio);
+    const next = scrubbing ? mapped : Math.max(mapped, lastDisplayedRef.current);
+    lastDisplayedRef.current = next;
+    reactNative.Animated.timing(progressAnim, {
+      duration: MOVIIE_SMART_PROGRESS_FILL_TRANSITION_MS,
+      toValue: next,
+      useNativeDriver: false
+    }).start();
+  }, [
+    barVisible,
+    durationOk,
+    progressAnim,
+    timelineScrubClockSeconds,
+    ui.currentTime,
+    ui.duration,
+    ui.playing
+  ]);
+  React.useEffect(() => {
+    if (!durationOk || !barVisible) {
+      return;
+    }
+    const sub = player.addListener("playToEnd", () => {
+      lastDisplayedRef.current = 1;
+      reactNative.Animated.timing(progressAnim, {
+        duration: MOVIIE_SMART_PROGRESS_FILL_TRANSITION_MS,
+        toValue: 1,
+        useNativeDriver: false
+      }).start();
+    });
+    return () => sub.remove();
+  }, [barVisible, durationOk, player, progressAnim]);
+  if (!playback.smartProgressEnabled || !durationOk) {
+    return null;
+  }
+  if (!barVisible) {
+    return null;
+  }
+  const widthInterpolated = progressAnim.interpolate({
+    extrapolate: "clamp",
+    inputRange: [0, 1],
+    outputRange: ["0%", "100%"]
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { pointerEvents: "none", style: styles.container, children: /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Animated.View,
+    {
+      style: [
+        styles.fill,
+        {
+          backgroundColor: accent,
+          width: widthInterpolated
+        }
+      ]
+    }
+  ) });
+}
+function resolveChromeControlPressOpacityStyle(pressed) {
+  return {
+    opacity: pressed ? MOVIIE_SKIN_CHROME_CONTROL_PRESSED_OPACITY : MOVIIE_SKIN_CHROME_CONTROL_REST_OPACITY
+  };
+}
+function createMoviieSkinOverlayStyles(layout) {
+  return reactNative.StyleSheet.create({
+    chromeScrimBase: {
+      backgroundColor: MOVIIE_SKIN_CHROME_SCRIM_BLACK_RGBA
+    },
+    floatingHud: {
+      bottom: 0,
+      left: 0,
+      pointerEvents: "box-none",
+      position: "absolute",
+      right: 0
+    },
+    floatingHudInner: {
+      alignItems: "center",
+      flexDirection: "row",
+      justifyContent: "space-between",
+      paddingBottom: layout.floatingHudAboveTimelineGapPx,
+      paddingHorizontal: layout.hudEdgeInsetPx
+    },
+    floatingLeftSpacer: {
+      flex: 1
+    },
+    floatingRight: {
+      alignItems: "center",
+      columnGap: layout.floatingHudButtonGapPx,
+      flexDirection: "row",
+      flexShrink: 0
+    },
+    clockScrim: {
+      borderRadius: layout.hudClockCornerRadiusPx,
+      overflow: "hidden",
+      paddingHorizontal: layout.hudEdgeInsetPx,
+      paddingVertical: layout.hudEdgeInsetPx
+    },
+    clockText: {
+      color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+      fontSize: layout.clockTextFontSizePx,
+      fontVariant: ["tabular-nums"]
+    },
+    centerCluster: {
+      ...reactNative.StyleSheet.absoluteFillObject,
+      alignItems: "center",
+      justifyContent: "center",
+      pointerEvents: "box-none"
+    },
+    centerClusterRow: {
+      alignItems: "center",
+      columnGap: layout.centerClusterColumnGapPx,
+      flexDirection: "row",
+      justifyContent: "center"
+    },
+    seekCircularScrim: {
+      alignItems: "center",
+      borderRadius: layout.seekScrimOuterDiameterPx / 2,
+      height: layout.seekScrimOuterDiameterPx,
+      justifyContent: "center",
+      overflow: "hidden",
+      width: layout.seekScrimOuterDiameterPx
+    },
+    playScrim: {
+      alignItems: "center",
+      borderRadius: layout.playScrimOuterDiameterPx / 2,
+      height: layout.playScrimOuterDiameterPx,
+      justifyContent: "center",
+      overflow: "hidden",
+      width: layout.playScrimOuterDiameterPx
+    },
+    playPlaceholder: {
+      height: layout.playScrimOuterDiameterPx,
+      width: layout.playScrimOuterDiameterPx
+    },
+    fullscreenHudCircleScrim: {
+      alignItems: "center",
+      borderRadius: layout.floatingHudFullscreenScrimDiameterPx / 2,
+      height: layout.floatingHudFullscreenScrimDiameterPx,
+      justifyContent: "center",
+      overflow: "hidden",
+      width: layout.floatingHudFullscreenScrimDiameterPx
+    },
+    topFullscreenCorner: {
+      alignItems: "center",
+      columnGap: layout.floatingHudButtonGapPx,
+      flexDirection: "row",
+      pointerEvents: "box-none",
+      position: "absolute",
+      right: layout.hudEdgeInsetPx,
+      top: layout.hudEdgeInsetPx,
+      zIndex: 8
+    }
+  });
+}
+function ChromeScrimPad(props) {
+  const padStyle = [props.chromeScrimBaseStyle, props.style];
+  if (props.onPress != null) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityLabel: props.accessibilityLabel,
+        accessibilityRole: props.accessibilityRole ?? "button",
+        hitSlop: props.hitSlop,
+        onPress: props.onPress,
+        style: (state) => [
+          props.chromeScrimBaseStyle,
+          props.style,
+          resolveChromeControlPressOpacityStyle(state.pressed)
+        ],
+        children: props.children
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: padStyle, children: props.children });
+}
+function MoviieSkinPictureInPictureCircleButton(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ChromeScrimPad,
+    {
+      accessibilityLabel: props.pictureInPictureActive ? "Fechar imagem no imagem" : "Imagem no imagem",
+      chromeScrimBaseStyle: props.styles.chromeScrimBase,
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      style: props.styles.fullscreenHudCircleScrim,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        EmbedMediaIconPictureInPicture,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenIconPx
+        }
+      )
+    }
+  );
+}
+function MoviieSkinPictureInPictureTopBareButton(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityLabel: props.pictureInPictureActive ? "Fechar imagem no imagem" : "Imagem no imagem",
+      accessibilityRole: "button",
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      style: (state) => resolveChromeControlPressOpacityStyle(state.pressed),
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        EmbedMediaIconPictureInPicture,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenTopIconPx * MOVIIE_SKIN_TOP_ICON_PIP_VISUAL_SCALE
+        }
+      )
+    }
+  );
+}
+function MoviieSkinFullscreenCircleButton(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ChromeScrimPad,
+    {
+      accessibilityLabel: props.isFullscreen ? "Sair de ecr\xE3 inteiro" : "Ecr\xE3 inteiro",
+      chromeScrimBaseStyle: props.styles.chromeScrimBase,
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      style: props.styles.fullscreenHudCircleScrim,
+      children: props.isFullscreen ? /* @__PURE__ */ jsxRuntime.jsx(
+        EmbedMediaIconFullscreenExit,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenIconPx
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx(
+        EmbedMediaIconFullscreen,
+        {
+          color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+          size: props.layout.floatingHudFullscreenIconPx
+        }
+      )
+    }
+  );
+}
+function MoviieSkinFullscreenTopBareButton(props) {
+  const size = props.layout.floatingHudFullscreenTopIconPx * MOVIIE_SKIN_TOP_ICON_FULLSCREEN_VISUAL_SCALE;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityLabel: props.isFullscreen ? "Sair de ecr\xE3 inteiro" : "Ecr\xE3 inteiro",
+      accessibilityRole: "button",
+      hitSlop: MOVIIE_SKIN_FLOATING_HUD_TRAILING_HIT_SLOP_PX,
+      onPress: props.onPress,
+      style: (state) => resolveChromeControlPressOpacityStyle(state.pressed),
+      children: props.isFullscreen ? /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconFullscreenExit, { color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX, size }) : /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconFullscreen, { color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX, size })
+    }
+  );
+}
+function MoviieSkinBufferingIndicator() {
+  const { isBuffering, layout } = useMoviieSkinChrome();
+  const bufferingHudStyle = React.useMemo(
+    () => ({
+      alignItems: "center",
+      height: layout.bufferingIndicatorSlotPx,
+      justifyContent: "center",
+      left: layout.hudEdgeInsetPx,
+      position: "absolute",
+      top: layout.hudEdgeInsetPx,
+      width: layout.bufferingIndicatorSlotPx,
+      zIndex: 16
+    }),
+    [layout]
+  );
+  if (!isBuffering) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { pointerEvents: "none", style: bufferingHudStyle, children: /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.ActivityIndicator,
+    {
+      accessibilityLabel: "A carregar v\xEDdeo",
+      color: MOVIIE_SKIN_CHROME_FOREGROUND_HEX,
+      size: "small"
+    }
+  ) });
+}
+function MoviieSkinVideoOverlay() {
+  const {
+    chromeOpacity,
+    chromeVisible,
+    bumpChromeInteraction,
+    castConnected,
+    castControlEnabled,
+    dismissChrome,
+    isCustomFullscreen,
+    openCastPicker,
+    pictureInPictureActive,
+    pictureInPictureControlEnabled,
+    toggleFullscreen,
+    togglePictureInPicture,
+    layout,
+    playback,
+    player,
+    seekBack,
+    seekForward,
+    timelineScrubClockSeconds,
+    togglePlay,
+    ui
+  } = useMoviieSkinChrome();
+  const handlePictureInPicturePress = React.useCallback(() => {
+    togglePictureInPicture();
+    dismissChrome();
+  }, [togglePictureInPicture, dismissChrome]);
+  const handleCastPress = React.useCallback(() => {
+    dismissChrome();
+    setTimeout(() => openCastPicker(), 150);
+  }, [openCastPicker, dismissChrome]);
+  const styles6 = React.useMemo(() => createMoviieSkinOverlayStyles(layout), [layout]);
+  const { controls } = playback;
+  const fg = MOVIIE_SKIN_CHROME_FOREGROUND_HEX;
+  const clockDisplaySeconds = timelineScrubClockSeconds ?? ui.currentTime;
+  const playbackEndedForUi = React.useMemo(
+    () => computeMoviiePlaybackEnded({
+      playing: ui.playing,
+      currentTime: clockDisplaySeconds,
+      duration: ui.duration,
+      isLive: player.isLive,
+      loop: player.loop
+    }),
+    [ui.playing, clockDisplaySeconds, ui.duration, player.isLive, player.loop]
+  );
+  const { centerSeekBackwardEnabled, centerSeekForwardEnabled } = React.useMemo(() => {
+    const alignSeekButtonsWithPlay = controls.showPlay && !player.isLive;
+    const hideSeekClusterAtEnd = playbackEndedForUi;
+    return {
+      centerSeekBackwardEnabled: !hideSeekClusterAtEnd && (controls.seekBackwardEnabled || alignSeekButtonsWithPlay),
+      centerSeekForwardEnabled: !hideSeekClusterAtEnd && (controls.seekForwardEnabled || alignSeekButtonsWithPlay)
+    };
+  }, [
+    controls.seekBackwardEnabled,
+    controls.seekForwardEnabled,
+    controls.showPlay,
+    player.isLive,
+    playbackEndedForUi
+  ]);
+  const centerPlayShowsReplay = playbackEndedForUi;
+  const centerPlayAccessibilityLabel = ui.playing ? "Pausar" : centerPlayShowsReplay ? "Come\xE7ar novamente" : "Reproduzir";
+  const clockLabel = controls.showCurrentTime || controls.showDuration ? formatPlaybackClock(clockDisplaySeconds, ui.duration) : null;
+  const showSeekCluster = centerSeekBackwardEnabled || centerSeekForwardEnabled || controls.showPlay;
+  const seekSlot = layout.seekScrimOuterDiameterPx;
+  const showPictureInPictureTrailing = pictureInPictureControlEnabled;
+  const showCastTrailing = castControlEnabled;
+  const hasFloatingHudTrailing = playback.branding.showWatermark || !playback.branding.showWatermark && (controls.showFullscreen || showPictureInPictureTrailing || showCastTrailing);
+  const showFloatingHud = clockLabel != null || hasFloatingHudTrailing;
+  const showFullscreenBottomTrailing = controls.showFullscreen && !playback.branding.showWatermark;
+  const showTopCornerChrome = playback.branding.showWatermark && (controls.showFullscreen || showPictureInPictureTrailing || showCastTrailing);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { pointerEvents: "box-none", style: reactNative.StyleSheet.absoluteFillObject, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityLabel: chromeVisible ? "\xC1rea do v\xEDdeo \u2014 toque para esconder os controles" : "Mostrar controles do v\xEDdeo",
+        accessibilityRole: "button",
+        onPress: chromeVisible ? dismissChrome : bumpChromeInteraction,
+        style: [reactNative.StyleSheet.absoluteFillObject, { zIndex: 0 }]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      AnimatedView,
+      {
+        pointerEvents: !chromeVisible ? "none" : "box-none",
+        style: [
+          reactNative.StyleSheet.absoluteFillObject,
+          {
+            opacity: chromeOpacity,
+            zIndex: 2
+          }
+        ],
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinChromeEdgeGradients, { layout, showProgress: controls.showProgress }),
+          showTopCornerChrome ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { pointerEvents: "box-none", style: styles6.topFullscreenCorner, children: [
+            showCastTrailing ? /* @__PURE__ */ jsxRuntime.jsx(
+              MoviieSkinCastTopBareButton,
+              {
+                castConnected,
+                layout,
+                onPress: handleCastPress
+              }
+            ) : null,
+            showPictureInPictureTrailing ? /* @__PURE__ */ jsxRuntime.jsx(
+              MoviieSkinPictureInPictureTopBareButton,
+              {
+                layout,
+                pictureInPictureActive,
+                onPress: handlePictureInPicturePress
+              }
+            ) : null,
+            controls.showFullscreen ? /* @__PURE__ */ jsxRuntime.jsx(
+              MoviieSkinFullscreenTopBareButton,
+              {
+                isFullscreen: isCustomFullscreen,
+                layout,
+                onPress: toggleFullscreen
+              }
+            ) : null
+          ] }) : null,
+          showFloatingHud ? /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.View,
+            {
+              pointerEvents: "box-none",
+              style: [
+                styles6.floatingHud,
+                controls.showProgress ? { bottom: layout.timelineStackHeightChromeVisiblePx } : null
+              ],
+              children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles6.floatingHudInner, children: [
+                clockLabel ? /* @__PURE__ */ jsxRuntime.jsx(
+                  ChromeScrimPad,
+                  {
+                    chromeScrimBaseStyle: styles6.chromeScrimBase,
+                    style: styles6.clockScrim,
+                    children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { accessibilityLabel: `Tempo ${clockLabel}`, style: styles6.clockText, children: clockLabel })
+                  }
+                ) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles6.floatingLeftSpacer }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles6.floatingRight, children: playback.branding.showWatermark ? /* @__PURE__ */ jsxRuntime.jsx(MoviieEmbedBrandMark, {}) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                  showCastTrailing ? /* @__PURE__ */ jsxRuntime.jsx(
+                    MoviieSkinCastCircleButton,
+                    {
+                      castConnected,
+                      chromeScrimBaseStyle: styles6.chromeScrimBase,
+                      circleScrimStyle: styles6.fullscreenHudCircleScrim,
+                      layout,
+                      onPress: handleCastPress
+                    }
+                  ) : null,
+                  showPictureInPictureTrailing ? /* @__PURE__ */ jsxRuntime.jsx(
+                    MoviieSkinPictureInPictureCircleButton,
+                    {
+                      layout,
+                      pictureInPictureActive,
+                      onPress: handlePictureInPicturePress,
+                      styles: styles6
+                    }
+                  ) : null,
+                  showFullscreenBottomTrailing ? /* @__PURE__ */ jsxRuntime.jsx(
+                    MoviieSkinFullscreenCircleButton,
+                    {
+                      isFullscreen: isCustomFullscreen,
+                      layout,
+                      onPress: toggleFullscreen,
+                      styles: styles6
+                    }
+                  ) : null
+                ] }) })
+              ] })
+            }
+          ) : null,
+          showSeekCluster ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { pointerEvents: "box-none", style: styles6.centerCluster, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles6.centerClusterRow, children: [
+            centerSeekBackwardEnabled ? /* @__PURE__ */ jsxRuntime.jsx(
+              ChromeScrimPad,
+              {
+                accessibilityLabel: "Retroceder 10 segundos",
+                chromeScrimBaseStyle: styles6.chromeScrimBase,
+                onPress: seekBack,
+                style: styles6.seekCircularScrim,
+                children: /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconSeekBackward10, { color: fg, size: layout.seekIconPx })
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { height: seekSlot, width: seekSlot } }),
+            controls.showPlay ? /* @__PURE__ */ jsxRuntime.jsx(
+              ChromeScrimPad,
+              {
+                accessibilityLabel: centerPlayAccessibilityLabel,
+                chromeScrimBaseStyle: styles6.chromeScrimBase,
+                onPress: togglePlay,
+                style: styles6.playScrim,
+                children: ui.playing ? /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconPause, { color: fg, size: layout.centerPlayIconPx }) : centerPlayShowsReplay ? /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconReplay, { color: fg, size: layout.centerPlayIconPx }) : /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconPlay, { color: fg, size: layout.centerPlayIconPx })
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles6.playPlaceholder }),
+            centerSeekForwardEnabled ? /* @__PURE__ */ jsxRuntime.jsx(
+              ChromeScrimPad,
+              {
+                accessibilityLabel: "Avan\xE7ar 10 segundos",
+                chromeScrimBaseStyle: styles6.chromeScrimBase,
+                onPress: seekForward,
+                style: styles6.seekCircularScrim,
+                children: /* @__PURE__ */ jsxRuntime.jsx(EmbedMediaIconSeekForward10, { color: fg, size: layout.seekIconPx })
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { height: seekSlot, width: seekSlot } })
+          ] }) }) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinBufferingIndicator, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinSmartProgress, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinBottomTimeline, {})
+  ] });
+}
+
+// src/lib/optional-status-bar.ts
+var cachedModule;
+function loadModule() {
+  if (cachedModule !== void 0) {
+    return cachedModule;
+  }
+  try {
+    cachedModule = __require("expo-status-bar");
+  } catch {
+    cachedModule = null;
+    warnOnce(
+      "moviie:expo-status-bar-missing",
+      "[@moviie/player-expo] `expo-status-bar` n\xE3o est\xE1 instalado. Status bar n\xE3o ser\xE1 ocultada em fullscreen JS. Instala com `pnpm add expo-status-bar` se quiser este comportamento."
+    );
+  }
+  return cachedModule;
+}
+function moviieSetStatusBarHidden(hidden, animation = "fade") {
+  const mod = loadModule();
+  if (mod == null) return;
+  try {
+    mod.setStatusBarHidden(hidden, animation);
+  } catch {
+  }
+}
+async function restoreOrientationLockPolicy(previousLock) {
+  try {
+    if (previousLock === void 0 || previousLock === expoScreenOrientation.OrientationLock.DEFAULT || previousLock === expoScreenOrientation.OrientationLock.UNKNOWN) {
+      await expoScreenOrientation.unlockAsync();
+      return;
+    }
+    await expoScreenOrientation.lockAsync(previousLock);
+  } catch {
+    try {
+      await expoScreenOrientation.unlockAsync();
+    } catch {
+    }
+  }
+}
+function subscribeCustomFullscreenNativeOrientation(targetLock) {
+  if (reactNative.Platform.OS === "web") {
+    return { finish: async () => {
+    } };
+  }
+  let cancelled = false;
+  let locked = false;
+  let previousLock;
+  const setup = (async () => {
+    try {
+      previousLock = await expoScreenOrientation.getOrientationLockAsync();
+      if (cancelled) {
+        return;
+      }
+      await expoScreenOrientation.lockAsync(targetLock);
+      if (cancelled) {
+        await restoreOrientationLockPolicy(previousLock);
+        return;
+      }
+      locked = true;
+    } catch {
+    }
+  })();
+  let finishPromise = null;
+  return {
+    finish: () => {
+      if (finishPromise != null) {
+        return finishPromise;
+      }
+      cancelled = true;
+      finishPromise = (async () => {
+        await setup;
+        if (locked) {
+          locked = false;
+          await restoreOrientationLockPolicy(previousLock);
+        }
+      })();
+      return finishPromise;
+    }
+  };
+}
+
+// src/lib/resolve-orientation-lock-for-rotate-z-deg.ts
+function resolveOrientationLockValueForRotateZDeg(rotateZDeg) {
+  {
+    return MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE.LANDSCAPE_RIGHT;
+  }
+}
+var CUSTOM_FULLSCREEN_TIMING = {
+  duration: MOVIIE_SKIN_CUSTOM_FULLSCREEN_TRANSITION_MS
+};
+var CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION = reactNative.Platform.OS === "web";
+var MoviieSkinCustomFullscreenModalInner = React.forwardRef(function MoviieSkinCustomFullscreenModalInner2(props, ref) {
+  const orientationFinishRef = React.useRef(null);
+  const insets = reactNativeSafeAreaContext.useSafeAreaInsets();
+  const { height: winH, width: winW } = reactNative.useWindowDimensions();
+  const { longSide, shortSide } = React.useMemo(
+    () => computeCustomFullscreenStageDimensions({
+      windowHeight: winH,
+      safeInsets: insets,
+      stageOverscanPx: MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_OVERSCAN_PX,
+      windowWidth: winW
+    }),
+    [winW, winH, insets.bottom, insets.left, insets.right, insets.top]
+  );
+  const rotateZDeg = AnimatedReanimated.useSharedValue(0);
+  const scale = AnimatedReanimated.useSharedValue(1);
+  const emitExitComplete = React.useCallback(() => {
+    props.onExitComplete();
+  }, [props.onExitComplete]);
+  const completeExitAfterNativeOrientationRestore = React.useCallback(() => {
+    void (async () => {
+      await orientationFinishRef.current?.();
+      emitExitComplete();
+    })();
+  }, [emitExitComplete]);
+  const animateExit = React.useCallback(() => {
+    scale.value = AnimatedReanimated.withTiming(
+      MOVIIE_SKIN_CUSTOM_FULLSCREEN_ENTER_SCALE_START,
+      CUSTOM_FULLSCREEN_TIMING,
+      (finishedScale) => {
+        if (!CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION && finishedScale) {
+          AnimatedReanimated.runOnJS(completeExitAfterNativeOrientationRestore)();
+        }
+      }
+    );
+    if (CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION) {
+      rotateZDeg.value = AnimatedReanimated.withTiming(0, CUSTOM_FULLSCREEN_TIMING, (finished) => {
+        if (finished) {
+          AnimatedReanimated.runOnJS(emitExitComplete)();
+        }
+      });
+      return;
+    }
+    rotateZDeg.value = 0;
+  }, [completeExitAfterNativeOrientationRestore, emitExitComplete, rotateZDeg, scale]);
+  React.useImperativeHandle(ref, () => ({ animateExit }), [animateExit]);
+  React.useEffect(() => {
+    if (!props.visible) {
+      return;
+    }
+    rotateZDeg.value = 0;
+    scale.value = MOVIIE_SKIN_CUSTOM_FULLSCREEN_ENTER_SCALE_START;
+    if (CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION) {
+      rotateZDeg.value = AnimatedReanimated.withTiming(
+        MOVIIE_SKIN_CUSTOM_FULLSCREEN_ROTATE_Z_DEGREES,
+        CUSTOM_FULLSCREEN_TIMING
+      );
+    }
+    scale.value = AnimatedReanimated.withTiming(1, CUSTOM_FULLSCREEN_TIMING);
+  }, [props.visible, rotateZDeg, scale]);
+  React.useEffect(() => {
+    if (!props.visible) {
+      return;
+    }
+    moviieSetStatusBarHidden(true, "fade");
+    return () => {
+      moviieSetStatusBarHidden(false, "fade");
+    };
+  }, [props.visible]);
+  React.useEffect(() => {
+    if (!props.visible || CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION) {
+      orientationFinishRef.current = null;
+      return;
+    }
+    const targetLock = resolveOrientationLockValueForRotateZDeg();
+    const sub = subscribeCustomFullscreenNativeOrientation(targetLock);
+    orientationFinishRef.current = () => sub.finish();
+    return () => {
+      orientationFinishRef.current = null;
+      void sub.finish();
+    };
+  }, [props.visible]);
+  const animatedStyle = AnimatedReanimated.useAnimatedStyle(() => {
+    if (CUSTOM_FULLSCREEN_USE_JS_STAGE_ROTATION) {
+      return {
+        transform: [{ rotateZ: `${rotateZDeg.value}deg` }, { scale: scale.value }]
+      };
+    }
+    return {
+      transform: [{ scale: scale.value }]
+    };
+  });
+  const stageStaticStyle = React.useMemo(
+    () => ({
+      height: shortSide,
+      width: longSide
+    }),
+    [longSide, shortSide]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: [styles2.root, { backgroundColor: MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_BACKGROUND_HEX }],
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles2.centerSheet, children: /* @__PURE__ */ jsxRuntime.jsx(ReanimatedView, { style: [styles2.rotatingStage, stageStaticStyle, animatedStyle], children: props.children }) })
+    }
+  );
+});
+var MoviieSkinCustomFullscreenModal = React.forwardRef(function MoviieSkinCustomFullscreenModal2(props, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      animationType: "none",
+      hardwareAccelerated: reactNative.Platform.OS === "android",
+      onRequestClose: () => {
+        if (ref != null && typeof ref !== "function") {
+          ref.current?.animateExit();
+        }
+      },
+      presentationStyle: "fullScreen",
+      statusBarTranslucent: reactNative.Platform.OS === "android",
+      supportedOrientations: [
+        "portrait",
+        "portrait-upside-down",
+        "landscape",
+        "landscape-left",
+        "landscape-right"
+      ],
+      visible: props.visible,
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNativeSafeAreaContext.SafeAreaProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinCustomFullscreenModalInner, { ref, ...props }) })
+    }
+  );
+});
+var styles2 = reactNative.StyleSheet.create({
+  root: {
+    flex: 1
+  },
+  centerSheet: {
+    alignItems: "center",
+    flex: 1,
+    justifyContent: "center",
+    overflow: "visible"
+  },
+  rotatingStage: {
+    position: "relative"
+  }
+});
+var ERROR_NUMERIC_CODE = {
+  auth: "E1001",
+  not_found: "E1002",
+  bundle_blocked: "E1003",
+  referrer_blocked: "E1004",
+  subscription_inactive: "E1005",
+  network: "E2001",
+  rate_limit: "E2002",
+  unknown: "E9999"
+};
+function resolveErrorCode(error) {
+  if (error instanceof playerSdk.MoviieAuthError) return "auth";
+  if (error instanceof playerSdk.MoviieNotFoundError) return "not_found";
+  if (error instanceof playerSdk.MoviieBundleBlockedError) return "bundle_blocked";
+  if (error instanceof playerSdk.MoviieReferrerBlockedError) return "referrer_blocked";
+  if (error instanceof playerSdk.MoviieSubscriptionInactiveError) return "subscription_inactive";
+  if (error instanceof playerSdk.MoviieNetworkError) return "network";
+  if (error instanceof playerSdk.MoviieRateLimitError) return "rate_limit";
+  const code = error.code;
+  if (typeof code === "string") {
+    const known = [
+      "auth",
+      "not_found",
+      "bundle_blocked",
+      "referrer_blocked",
+      "subscription_inactive",
+      "network",
+      "rate_limit"
+    ];
+    if (known.includes(code)) {
+      return code;
+    }
+  }
+  return "unknown";
+}
+function getErrorDisplay(error) {
+  const code = resolveErrorCode(error);
+  switch (code) {
+    case "auth":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Configura\xE7\xE3o inv\xE1lida",
+        description: "Verifique a chave public\xE1vel do SDK.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL
+      };
+    case "not_found":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Reprodu\xE7\xE3o indispon\xEDvel",
+        description: "N\xE3o conseguimos encontrar este v\xEDdeo.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL
+      };
+    case "bundle_blocked":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Aplicativo n\xE3o autorizado",
+        description: "Este aplicativo n\xE3o est\xE1 autorizado a reproduzir este v\xEDdeo.",
+        ctaLabel: "Ajustar permiss\xF5es",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL
+      };
+    case "referrer_blocked":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Origem n\xE3o autorizada",
+        description: "Origem n\xE3o autorizada para reprodu\xE7\xE3o.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL
+      };
+    case "subscription_inactive":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Reprodu\xE7\xE3o temporariamente indispon\xEDvel",
+        description: "Acesse a Moviie para continuar assistindo.",
+        ctaLabel: "Ir para a Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL
+      };
+    case "network":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Erro de conex\xE3o",
+        description: "Verifique sua conex\xE3o e tente novamente.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null
+      };
+    case "rate_limit":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Muitas solicita\xE7\xF5es",
+        description: "Aguarde alguns instantes e tente novamente.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null
+      };
+    case "unknown":
+    default:
+      return {
+        code: "unknown",
+        numericCode: ERROR_NUMERIC_CODE["unknown"],
+        heading: "Erro tempor\xE1rio",
+        description: "Tente novamente em instantes.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null
+      };
+  }
+}
+function MoviiePlayerErrorShell({
+  error,
+  onRetry
+}) {
+  const display = getErrorDisplay(error);
+  const handlePress = React.useCallback(() => {
+    if (display.ctaKind === "retry") {
+      onRetry?.();
+      return;
+    }
+    if (display.ctaKind === "external" && display.externalUrl) {
+      void reactNative.Linking.openURL(display.externalUrl).catch(() => {
+      });
+    }
+  }, [display, onRetry]);
+  const showCta = display.ctaLabel != null && display.ctaKind !== "none";
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.root, accessibilityRole: "alert", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles3.radialGlow }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.errorCode, selectable: true, children: display.numericCode }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.content, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.heading, numberOfLines: 2, children: display.heading }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.description, numberOfLines: 4, children: display.description }),
+      showCta ? /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          accessibilityRole: "button",
+          accessibilityLabel: display.ctaLabel ?? void 0,
+          onPress: handlePress,
+          style: ({ pressed }) => [styles3.button, pressed ? styles3.buttonPressed : null],
+          children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.buttonLabel, children: display.ctaLabel })
+        }
+      ) : null
+    ] })
+  ] });
+}
+var styles3 = reactNative.StyleSheet.create({
+  root: {
+    ...reactNative.StyleSheet.absoluteFillObject,
+    backgroundColor: MOVIIE_SHELL_BACKGROUND_HEX,
+    overflow: "hidden",
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  /** Simulates radial gradient: dark outer, lighter center. */
+  radialGlow: {
+    position: "absolute",
+    width: "150%",
+    aspectRatio: 1,
+    borderRadius: 9999,
+    backgroundColor: MOVIIE_SHELL_RADIAL_INNER_HEX
+  },
+  content: {
+    ...reactNative.StyleSheet.absoluteFillObject,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 24,
+    gap: 10
+  },
+  heading: {
+    color: MOVIIE_SHELL_HEADING_HEX,
+    fontSize: MOVIIE_SHELL_HEADING_FONT_SIZE_PX,
+    fontWeight: "600",
+    textAlign: "center",
+    maxWidth: MOVIIE_SHELL_CONTENT_MAX_WIDTH_PX
+  },
+  description: {
+    color: MOVIIE_SHELL_DESCRIPTION_HEX,
+    fontSize: MOVIIE_SHELL_DESCRIPTION_FONT_SIZE_PX,
+    lineHeight: 20,
+    textAlign: "center",
+    maxWidth: MOVIIE_SHELL_CONTENT_MAX_WIDTH_PX
+  },
+  errorCode: {
+    position: "absolute",
+    bottom: 8,
+    right: 10,
+    color: MOVIIE_SHELL_ERROR_CODE_HEX,
+    fontSize: 10,
+    fontFamily: "Menlo",
+    opacity: 0.45,
+    zIndex: 2
+  },
+  button: {
+    marginTop: 6,
+    paddingVertical: MOVIIE_SHELL_BUTTON_PADDING_V_PX,
+    paddingHorizontal: MOVIIE_SHELL_BUTTON_PADDING_H_PX,
+    backgroundColor: MOVIIE_SHELL_BUTTON_BG_HEX,
+    borderColor: MOVIIE_SHELL_BUTTON_BORDER_RGBA,
+    borderWidth: reactNative.StyleSheet.hairlineWidth * 2,
+    borderRadius: MOVIIE_SHELL_BUTTON_RADIUS_PX
+  },
+  buttonPressed: {
+    opacity: MOVIIE_SKIN_CHROME_CONTROL_PRESSED_OPACITY
+  },
+  buttonLabel: {
+    color: MOVIIE_SHELL_BUTTON_LABEL_HEX,
+    fontSize: MOVIIE_SHELL_BUTTON_LABEL_FONT_SIZE_PX,
+    fontWeight: "600",
+    textAlign: "center"
+  }
+});
+function MoviiePlayerLoadingShell({
+  posterUrl,
+  primaryColor
+}) {
+  const accent = resolveSkinAccentColor(primaryColor ?? null);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles4.root, accessibilityRole: "progressbar", accessibilityLabel: "Carregando v\xEDdeo", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles4.radialGlow }),
+    posterUrl ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Image, { source: { uri: posterUrl }, style: styles4.poster, resizeMode: "cover" }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles4.center, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { size: "large", color: accent }) })
+  ] });
+}
+var styles4 = reactNative.StyleSheet.create({
+  root: {
+    ...reactNative.StyleSheet.absoluteFillObject,
+    backgroundColor: MOVIIE_SHELL_BACKGROUND_HEX,
+    overflow: "hidden",
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  /** Simulates radial gradient: dark outer, lighter center. */
+  radialGlow: {
+    position: "absolute",
+    width: "150%",
+    aspectRatio: 1,
+    borderRadius: 9999,
+    backgroundColor: MOVIIE_SHELL_RADIAL_INNER_HEX
+  },
+  poster: {
+    ...reactNative.StyleSheet.absoluteFillObject,
+    opacity: 0.35
+  },
+  center: {
+    ...reactNative.StyleSheet.absoluteFillObject,
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});
+function assignForwardedRef(forwarded, instance) {
+  if (typeof forwarded === "function") {
+    forwarded(instance);
+    return;
+  }
+  if (forwarded) {
+    forwarded.current = instance;
+  }
+}
+var HostVideoView = expoVideo.VideoView;
+var CROSSFADE_TIMING = {
+  duration: MOVIIE_SHELL_CROSSFADE_DURATION_MS,
+  easing: AnimatedReanimated.Easing.out(AnimatedReanimated.Easing.quad)
+};
+var MoviieVideo = React.forwardRef(
+  function MoviieVideo2(props, ref) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNativeSafeAreaContext.SafeAreaProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(MoviieVideoImpl, { ref, ...props }) });
+  }
+);
+var MoviieVideoImpl = React.forwardRef(
+  function MoviieVideoImpl2(props, forwardedRef) {
+    const {
+      player,
+      nativeControls,
+      native = false,
+      playback = null,
+      controlsAutoHideMs,
+      controlsVisibleByDefault,
+      pictureInPicture,
+      pictureInPictureAutoStart,
+      allowsPictureInPicture: passthroughAllowsPictureInPicture,
+      startsPictureInPictureAutomatically: passthroughStartsPictureInPictureAutomatically,
+      requiresLinearPlayback: passthroughRequiresLinearPlayback,
+      onPictureInPictureStart: userOnPictureInPictureStart,
+      onPictureInPictureStop: userOnPictureInPictureStop,
+      children,
+      style,
+      contentFit,
+      error = null,
+      isLoading = false,
+      aspectRatio,
+      onRetry,
+      retry,
+      castAdapter: castAdapterProp,
+      cast,
+      onTelemetryError,
+      onTelemetryEvent,
+      ...videoRest
+    } = props;
+    const castAdapter = castAdapterProp ?? getRegisteredCastAdapter();
+    const lastReportedErrorRef = React.useRef(null);
+    React.useEffect(() => {
+      if (error == null) {
+        lastReportedErrorRef.current = null;
+        return;
+      }
+      if (lastReportedErrorRef.current === error) {
+        return;
+      }
+      lastReportedErrorRef.current = error;
+      safeInvokeMoviieTelemetry(onTelemetryError, error, {
+        phase: "playback_fetch"
+      });
+    }, [error, onTelemetryError]);
+    const useMoviieChrome = !native;
+    const shellState = playback != null ? "ready" : error != null ? "error" : "loading";
+    const loadingOpacity = AnimatedReanimated.useSharedValue(shellState === "loading" ? 1 : 0);
+    const errorOpacity = AnimatedReanimated.useSharedValue(shellState === "error" ? 1 : 0);
+    const playerOpacity = AnimatedReanimated.useSharedValue(shellState === "ready" ? 1 : 0);
+    React.useEffect(() => {
+      loadingOpacity.value = AnimatedReanimated.withTiming(shellState === "loading" ? 1 : 0, CROSSFADE_TIMING);
+      errorOpacity.value = AnimatedReanimated.withTiming(shellState === "error" ? 1 : 0, CROSSFADE_TIMING);
+      playerOpacity.value = AnimatedReanimated.withTiming(shellState === "ready" ? 1 : 0, CROSSFADE_TIMING);
+    }, [shellState, loadingOpacity, errorOpacity, playerOpacity]);
+    const loadingAnimatedStyle = AnimatedReanimated.useAnimatedStyle(() => ({
+      opacity: loadingOpacity.value
+    }));
+    const errorAnimatedStyle = AnimatedReanimated.useAnimatedStyle(() => ({
+      opacity: errorOpacity.value
+    }));
+    const playerAnimatedStyle = AnimatedReanimated.useAnimatedStyle(() => ({
+      opacity: playerOpacity.value
+    }));
+    const effectiveOnRetry = React.useMemo(() => {
+      if (onRetry) return onRetry;
+      if (retry) return retry;
+      return void 0;
+    }, [onRetry, retry]);
+    const nativePresentationVideoProps = React.useMemo(() => {
+      if (playback != null) {
+        const embedBaseline = buildMoviieVideoPresentationProps({
+          pictureInPicture,
+          pictureInPictureAutoStart,
+          profile: playback.profile,
+          showPip: playback.controls.showPip
+        });
+        return {
+          allowsPictureInPicture: passthroughAllowsPictureInPicture ?? embedBaseline.allowsPictureInPicture,
+          startsPictureInPictureAutomatically: passthroughStartsPictureInPictureAutomatically ?? embedBaseline.startsPictureInPictureAutomatically,
+          requiresLinearPlayback: passthroughRequiresLinearPlayback ?? embedBaseline.requiresLinearPlayback
+        };
+      }
+      return {
+        allowsPictureInPicture: passthroughAllowsPictureInPicture ?? false,
+        startsPictureInPictureAutomatically: passthroughStartsPictureInPictureAutomatically ?? false,
+        requiresLinearPlayback: passthroughRequiresLinearPlayback ?? false
+      };
+    }, [
+      playback,
+      pictureInPicture,
+      pictureInPictureAutoStart,
+      passthroughAllowsPictureInPicture,
+      passthroughStartsPictureInPictureAutomatically,
+      passthroughRequiresLinearPlayback
+    ]);
+    const pipControlEnabled = React.useMemo(() => {
+      if (!playback || !useMoviieChrome) {
+        return false;
+      }
+      return expoVideo.isPictureInPictureSupported() && nativePresentationVideoProps.allowsPictureInPicture;
+    }, [playback, useMoviieChrome, nativePresentationVideoProps.allowsPictureInPicture]);
+    const innerRef = React.useRef(null);
+    const fullscreenModalRef = React.useRef(null);
+    const [customFullscreen, setCustomFullscreen] = React.useState(false);
+    const [pipActive, setPipActive] = React.useState(false);
+    const [castState, setCastState] = React.useState(
+      () => castAdapter?.isAvailable() ? castAdapter.getState() : "unavailable"
+    );
+    const castDesired = React.useMemo(() => {
+      if (!playback || !useMoviieChrome) return false;
+      if (cast === false) return false;
+      if (cast === true) return true;
+      return playback.controls.chromecast === true;
+    }, [cast, playback, useMoviieChrome]);
+    const castControlEnabled = React.useMemo(() => {
+      if (!castDesired) return false;
+      return castAdapter?.isAvailable() === true;
+    }, [castAdapter, castDesired]);
+    const castConnected = castState === "connected";
+    const openCastPicker = React.useCallback(() => {
+      void castAdapter?.showDevicePicker().catch(() => {
+      });
+    }, [castAdapter]);
+    React.useEffect(() => {
+      if (!castAdapter?.isAvailable()) {
+        setCastState("unavailable");
+        return;
+      }
+      setCastState(castAdapter.getState());
+      const unsubscribe = castAdapter.subscribe((next) => {
+        setCastState(next);
+      });
+      return () => {
+        unsubscribe();
+      };
+    }, [castAdapter]);
+    React.useEffect(() => {
+      if (castDesired && (!castAdapter || !castAdapter.isAvailable())) {
+        warnOnce(
+          "moviie-cast-missing-adapter",
+          '[@moviie/player-expo] O embed habilita Chromecast mas a lib n\xE3o est\xE1 dispon\xEDvel. Instale `react-native-google-cast` e adicione `import "@moviie/player-expo/cast"` no seu _layout.tsx (ver docs/player-expo/cast). Para desligar explicitamente, passe `cast={false}` em <MoviieVideo />.'
+        );
+      }
+    }, [castDesired, castAdapter]);
+    React.useEffect(() => {
+      if (!castAdapter?.isAvailable() || !playback || !player) return;
+      if (castState !== "connected") return;
+      const startSeconds = player.currentTime ?? 0;
+      void castAdapter.loadMedia({
+        uri: playback.playback.uri,
+        title: playback.title,
+        posterUrl: playback.posterUrl,
+        durationSeconds: playback.durationSeconds ?? null,
+        startSeconds
+      }).then(() => {
+        try {
+          player.pause();
+        } catch {
+        }
+      }).catch(() => {
+      });
+    }, [castAdapter, castState, playback, player]);
+    const { width: winW, height: winH } = reactNative.useWindowDimensions();
+    const safeAreaInsets = reactNativeSafeAreaContext.useSafeAreaInsets();
+    const fullscreenStageLayout = React.useMemo(
+      () => computeCustomFullscreenStageDimensions({
+        windowHeight: winH,
+        safeInsets: safeAreaInsets,
+        stageOverscanPx: MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_OVERSCAN_PX,
+        windowWidth: winW
+      }),
+      [
+        winW,
+        winH,
+        safeAreaInsets.bottom,
+        safeAreaInsets.left,
+        safeAreaInsets.right,
+        safeAreaInsets.top
+      ]
+    );
+    React.useEffect(() => {
+      setPipActive(false);
+    }, [playback?.embedId]);
+    const handleNativePictureInPictureStart = React.useCallback(() => {
+      if (useMoviieChrome && playback != null) {
+        setPipActive(true);
+      }
+      userOnPictureInPictureStart?.();
+    }, [playback, useMoviieChrome, userOnPictureInPictureStart]);
+    const handleNativePictureInPictureStop = React.useCallback(() => {
+      if (useMoviieChrome && playback != null) {
+        setPipActive(false);
+      }
+      userOnPictureInPictureStop?.();
+    }, [playback, useMoviieChrome, userOnPictureInPictureStop]);
+    const togglePictureInPicture = React.useCallback(async () => {
+      const surface = innerRef.current;
+      if (!surface?.startPictureInPicture) {
+        return;
+      }
+      try {
+        if (pipActive) {
+          await surface.stopPictureInPicture?.();
+        } else {
+          await surface.startPictureInPicture();
+        }
+      } catch {
+      }
+    }, [pipActive]);
+    const requestExitCustomFullscreenAnimated = React.useCallback(() => {
+      fullscreenModalRef.current?.animateExit();
+    }, []);
+    const setRefs = React.useCallback(
+      (node) => {
+        innerRef.current = node;
+        assignForwardedRef(forwardedRef, node);
+      },
+      [forwardedRef]
+    );
+    const resolvedNativeControlsDefault = native ? playback?.profile === MOVIIE_PLAYBACK_PROFILE.VSL ? false : true : false;
+    const effectiveNativeControls = nativeControls ?? resolvedNativeControlsDefault;
+    const intrinsicAspectRatio = playback?.videoWidthPx != null && playback?.videoHeightPx != null && playback.videoWidthPx > 0 && playback.videoHeightPx > 0 ? playback.videoWidthPx / playback.videoHeightPx : null;
+    const effectiveAspectRatio = intrinsicAspectRatio ?? aspectRatio ?? MOVIIE_SHELL_DEFAULT_ASPECT_RATIO;
+    const effectiveContentFit = contentFit ?? (playback != null ? playback.isVertical ? MOVIIE_VIDEO_DEFAULT_CONTENT_FIT.VERTICAL : MOVIIE_VIDEO_DEFAULT_CONTENT_FIT.HORIZONTAL : void 0);
+    const { columnStyle, surfaceStyle } = partitionMoviieVideoHostStyle(reactNative.StyleSheet.flatten(style));
+    const stageContainerStyle = [
+      styles5.videoStage,
+      {
+        width: "100%",
+        aspectRatio: effectiveAspectRatio,
+        alignSelf: "stretch",
+        flex: 0
+      },
+      surfaceStyle,
+      useMoviieChrome && playback ? styles5.videoStageClipNone : null
+    ];
+    const inlineVideoAndOverlay = player != null ? useMoviieChrome && playback ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      React.createElement(HostVideoView, {
+        ...videoRest,
+        ...nativePresentationVideoProps,
+        ref: setRefs,
+        player,
+        nativeControls: effectiveNativeControls,
+        onPictureInPictureStart: handleNativePictureInPictureStart,
+        onPictureInPictureStop: handleNativePictureInPictureStop,
+        ...effectiveContentFit != null ? { contentFit: effectiveContentFit } : {},
+        style: styles5.videoFill
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinVideoOverlay, {})
+    ] }) : React.createElement(HostVideoView, {
+      ...videoRest,
+      ...nativePresentationVideoProps,
+      ref: setRefs,
+      player,
+      nativeControls: effectiveNativeControls,
+      onPictureInPictureStart: handleNativePictureInPictureStart,
+      onPictureInPictureStop: handleNativePictureInPictureStop,
+      ...effectiveContentFit != null ? { contentFit: effectiveContentFit } : {},
+      style: styles5.videoFill
+    }) : null;
+    const renderInlineStage = (active) => {
+      if (!playback || !useMoviieChrome) {
+        return inlineVideoAndOverlay;
+      }
+      if (!customFullscreen) {
+        return inlineVideoAndOverlay;
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.View,
+        {
+          style: [
+            styles5.videoFill,
+            {
+              backgroundColor: MOVIIE_SKIN_CUSTOM_FULLSCREEN_STAGE_BACKGROUND_HEX
+            }
+          ]
+        }
+      );
+    };
+    const stageContent = /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: stageContainerStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ReanimatedView,
+        {
+          style: [reactNative.StyleSheet.absoluteFillObject, loadingAnimatedStyle, styles5.shellLayer],
+          pointerEvents: shellState === "loading" ? "auto" : "none",
+          children: shellState === "loading" || loadingOpacity.value > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+            MoviiePlayerLoadingShell,
+            {
+              posterUrl: playback?.posterUrl ?? null,
+              primaryColor: playback?.branding.primaryColor ?? null
+            }
+          ) : null
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ReanimatedView,
+        {
+          style: [reactNative.StyleSheet.absoluteFillObject, errorAnimatedStyle, styles5.shellLayer],
+          pointerEvents: shellState === "error" ? "auto" : "none",
+          children: error ? /* @__PURE__ */ jsxRuntime.jsx(MoviiePlayerErrorShell, { error, onRetry: effectiveOnRetry }) : null
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ReanimatedView,
+        {
+          style: [reactNative.StyleSheet.absoluteFillObject, playerAnimatedStyle],
+          pointerEvents: shellState === "ready" ? "auto" : "none",
+          children: renderInlineStage()
+        }
+      )
+    ] });
+    if (useMoviieChrome && playback && player) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        MoviieSkinChromeProvider,
+        {
+          autoHideMs: controlsAutoHideMs,
+          customFullscreen,
+          pictureInPictureActive: pipActive,
+          pictureInPictureControlEnabled: pipControlEnabled,
+          togglePictureInPicture,
+          castControlEnabled,
+          castConnected,
+          openCastPicker,
+          onRequestEnterCustomFullscreen: () => setCustomFullscreen(true),
+          onRequestExitCustomFullscreenAnimated: requestExitCustomFullscreenAnimated,
+          playback,
+          player,
+          skinLayoutMetricsWidth: customFullscreen ? fullscreenStageLayout.layoutMetricsBasisWidth : void 0,
+          videoViewRef: innerRef,
+          visibleByDefault: controlsVisibleByDefault,
+          children: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles5.column, columnStyle], children: [
+              stageContent,
+              children
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              MoviieSkinCustomFullscreenModal,
+              {
+                ref: fullscreenModalRef,
+                visible: customFullscreen,
+                onExitComplete: () => setCustomFullscreen(false),
+                children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles5.fullscreenStage, children: [
+                  React.createElement(HostVideoView, {
+                    ...videoRest,
+                    ...nativePresentationVideoProps,
+                    ref: setRefs,
+                    player,
+                    nativeControls: effectiveNativeControls,
+                    onPictureInPictureStart: handleNativePictureInPictureStart,
+                    onPictureInPictureStop: handleNativePictureInPictureStop,
+                    contentFit: MOVIIE_SKIN_CUSTOM_FULLSCREEN_VIDEO_CONTENT_FIT,
+                    style: reactNative.StyleSheet.absoluteFillObject
+                  }),
+                  /* @__PURE__ */ jsxRuntime.jsx(MoviieSkinVideoOverlay, {})
+                ] })
+              }
+            )
+          ] })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles5.column, columnStyle], children: [
+      stageContent,
+      children,
+      castAdapter?.renderAndroidProxy?.()
+    ] });
+  }
+);
+var styles5 = reactNative.StyleSheet.create({
+  column: {
+    alignSelf: "stretch",
+    width: "100%"
+  },
+  videoStage: {
+    overflow: "hidden",
+    position: "relative",
+    width: "100%"
+  },
+  videoStageClipNone: {
+    overflow: "visible"
+  },
+  videoFill: {
+    flex: 1,
+    width: "100%",
+    alignSelf: "stretch"
+  },
+  fullscreenStage: {
+    flex: 1,
+    position: "relative",
+    width: "100%"
+  },
+  shellLayer: {
+    zIndex: 1
+  }
+});
+var MoviieErrorBoundary = class extends React__default.default.Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    if (this.props.onError != null) {
+      try {
+        this.props.onError(error, info);
+      } catch {
+      }
+    }
+  }
+  reset = () => {
+    this.setState({ error: null });
+  };
+  render() {
+    if (this.state.error != null) {
+      if (this.props.fallback != null) {
+        return this.props.fallback({
+          error: this.state.error,
+          reset: this.reset
+        });
+      }
+      return null;
+    }
+    return this.props.children;
+  }
+};
+
+Object.defineProperty(exports, "PLAYER_API_EVENTS", {
+  enumerable: true,
+  get: function () { return playerTypes.PLAYER_API_EVENTS; }
+});
+Object.defineProperty(exports, "PLAYER_API_METHODS", {
+  enumerable: true,
+  get: function () { return playerTypes.PLAYER_API_METHODS; }
+});
+Object.defineProperty(exports, "PLAYER_API_PROPERTIES", {
+  enumerable: true,
+  get: function () { return playerTypes.PLAYER_API_PROPERTIES; }
+});
+exports.EXPO_PUBLIC_MOVIIE_API_BASE_URL_ENV = EXPO_PUBLIC_MOVIIE_API_BASE_URL_ENV;
+exports.EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL_ENV = EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL_ENV;
+exports.EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN_ENV = EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN_ENV;
+exports.MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS = MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS;
+exports.MOVIIE_PLAYBACK_PROFILE = MOVIIE_PLAYBACK_PROFILE;
+exports.MOVIIE_PLAYER_EXPO_EMBED_JS_MARKER_ATTR = MOVIIE_PLAYER_EXPO_EMBED_JS_MARKER_ATTR;
+exports.MOVIIE_PLAYER_EXPO_PKG_VERSION = MOVIIE_PLAYER_EXPO_PKG_VERSION;
+exports.MOVIIE_REMEMBER_POSITION_DEBOUNCE_MS = MOVIIE_REMEMBER_POSITION_DEBOUNCE_MS;
+exports.MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX = MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX;
+exports.MOVIIE_SKIN_CONTROLS_AUTO_HIDE_MS = MOVIIE_SKIN_CONTROLS_AUTO_HIDE_MS;
+exports.MOVIIE_SKIN_CONTROL_ICON_PX = MOVIIE_SKIN_CONTROL_ICON_PX;
+exports.MOVIIE_SKIN_DEFAULT_ACCENT_HEX = MOVIIE_SKIN_DEFAULT_ACCENT_HEX;
+exports.MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS = MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS;
+exports.MOVIIE_SKIN_VOLUME_LOW_ICON_THRESHOLD = MOVIIE_SKIN_VOLUME_LOW_ICON_THRESHOLD;
+exports.MOVIIE_VIDEO_DEFAULT_CONTENT_FIT = MOVIIE_VIDEO_DEFAULT_CONTENT_FIT;
+exports.MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY = MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY;
+exports.MOVIIE_WATCH_EMBED_JS_PATH = MOVIIE_WATCH_EMBED_JS_PATH;
+exports.MOVIIE_WATCH_ORIGIN_DEFAULT = MOVIIE_WATCH_ORIGIN_DEFAULT;
+exports.MoviieErrorBoundary = MoviieErrorBoundary;
+exports.MoviieProvider = MoviieProvider;
+exports.MoviieVideo = MoviieVideo;
+exports.SecureStoreViewerTokenStore = SecureStoreViewerTokenStore;
+exports.addMoviiePlaybackEndedListener = addMoviiePlaybackEndedListener;
+exports.buildMoviieVideoPresentationProps = buildMoviieVideoPresentationProps;
+exports.buildMoviieWatchEmbedUrl = buildMoviieWatchEmbedUrl;
+exports.computeMoviiePlaybackEnded = computeMoviiePlaybackEnded;
+exports.normalizeWatchOrigin = normalizeWatchOrigin;
+exports.resolveMoviieWatchOrigin = resolveMoviieWatchOrigin;
+exports.useMoviieContext = useMoviieContext;
+exports.useMoviieEvent = useMoviieEvent;
+exports.useMoviiePlayback = useMoviiePlayback;
+exports.useMoviiePlaybackEnded = useMoviiePlaybackEnded;
+exports.useMoviiePlayer = useMoviiePlayer;
+Object.keys(playerSdk).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return playerSdk[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map