@moviie/player-sdk 0.2.0

package/dist/index.cjs

@@ -0,0 +1,768 @@
+'use strict';
+
+var zod = require('zod');
+var playerTypes = require('@moviie/player-types');
+
+// src/client/moviie-client.ts
+
+// src/constants.ts
+var MOVIIE_DEFAULT_API_BASE_URL = "https://api.moviie.ai/v1";
+var MOVIIE_TELEMETRY_API_PATH_PREFIX = "/telemetry/v1";
+var SDK_PUBLIC_API_KEY_PREFIX_PUBLISHABLE = "mvi_pub_";
+var SDK_PLAYBACK_AUTH_ERROR_MESSAGE = {
+  KEY_REQUIRED: "Publishable API key is required for playback.",
+  PRIVATE_KEY_FORBIDDEN: "Do not use a private API key for playback; use a publishable key (mvi_pub_*)."
+};
+var HTTP_HEADER_MOVIIE_REASON = "x-moviie-reason";
+var MOVIIE_BLOCK_REASON = {
+  BUNDLE: "bundle"
+};
+
+// src/config/moviie-endpoints.ts
+var configuredApiBaseUrl = null;
+var configuredEventsBaseUrl = null;
+function normalizeEndpointBase(raw) {
+  return raw.trim().replace(/\/+$/, "");
+}
+function deriveMoviieTelemetryBaseUrlFromApiBaseUrl(apiBaseUrl) {
+  const trimmed = normalizeEndpointBase(apiBaseUrl);
+  const href = trimmed.includes("://") ? trimmed : `https://${trimmed}`;
+  const u = new URL(href);
+  return normalizeEndpointBase(`${u.origin}${MOVIIE_TELEMETRY_API_PATH_PREFIX}`);
+}
+function configureMoviieEndpoints(options) {
+  if (options.apiBaseUrl !== void 0) {
+    if (options.apiBaseUrl == null || options.apiBaseUrl.trim() === "") {
+      configuredApiBaseUrl = null;
+    } else {
+      configuredApiBaseUrl = normalizeEndpointBase(options.apiBaseUrl);
+    }
+  }
+  if (options.eventsBaseUrl !== void 0) {
+    if (options.eventsBaseUrl == null || options.eventsBaseUrl.trim() === "") {
+      configuredEventsBaseUrl = null;
+    } else {
+      configuredEventsBaseUrl = normalizeEndpointBase(options.eventsBaseUrl);
+    }
+  }
+}
+function resetMoviieEndpointsConfiguration() {
+  configuredApiBaseUrl = null;
+  configuredEventsBaseUrl = null;
+}
+function getMoviieApiBaseUrl() {
+  return configuredApiBaseUrl ?? MOVIIE_DEFAULT_API_BASE_URL;
+}
+function getMoviieEventsBaseUrl() {
+  if (process.env.NODE_ENV === "test" && process.env.MOVIIE_PLAYER_SDK_TEST_EVENTS_BASE?.trim()) {
+    return normalizeEndpointBase(process.env.MOVIIE_PLAYER_SDK_TEST_EVENTS_BASE);
+  }
+  if (configuredEventsBaseUrl != null) {
+    return configuredEventsBaseUrl;
+  }
+  return deriveMoviieTelemetryBaseUrlFromApiBaseUrl(getMoviieApiBaseUrl());
+}
+var MOVIIE_CDN_BASE = "https://cdn.moviie.ai";
+var MOVIIE_WATCH_BASE = "https://watch.moviie.ai";
+
+// src/client/errors.ts
+var MoviieAuthError = class extends Error {
+  code = "auth";
+  constructor(message = "Autentica\xE7\xE3o necess\xE1ria ou chave inv\xE1lida") {
+    super(message);
+    this.name = "MoviieAuthError";
+  }
+};
+var MoviieNotFoundError = class extends Error {
+  code = "not_found";
+  constructor(message = "Recurso n\xE3o encontrado") {
+    super(message);
+    this.name = "MoviieNotFoundError";
+  }
+};
+var MoviieBundleBlockedError = class extends Error {
+  code = "bundle_blocked";
+  constructor(message = "Este aplicativo n\xE3o est\xE1 autorizado a reproduzir este v\xEDdeo") {
+    super(message);
+    this.name = "MoviieBundleBlockedError";
+  }
+};
+var MoviieReferrerBlockedError = class extends Error {
+  code = "referrer_blocked";
+  constructor(message = "Origem n\xE3o autorizada para reprodu\xE7\xE3o") {
+    super(message);
+    this.name = "MoviieReferrerBlockedError";
+  }
+};
+var MoviieSubscriptionInactiveError = class extends Error {
+  code = "subscription_inactive";
+  constructor(message = "Reprodu\xE7\xE3o temporariamente indispon\xEDvel para esta organiza\xE7\xE3o") {
+    super(message);
+    this.name = "MoviieSubscriptionInactiveError";
+  }
+};
+var MoviieNetworkError = class extends Error {
+  code = "network";
+  constructor(message = "Falha de rede. Tente novamente") {
+    super(message);
+    this.name = "MoviieNetworkError";
+  }
+};
+var MoviieRateLimitError = class extends Error {
+  code = "rate_limit";
+  constructor(message = "Muitas solicita\xE7\xF5es. Aguarde e tente novamente") {
+    super(message);
+    this.name = "MoviieRateLimitError";
+  }
+};
+
+// src/client/http.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRIES = 2;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelayMs(attempt) {
+  const base = 2 ** attempt * 200;
+  const jitter = Math.floor(Math.random() * 200);
+  return base + jitter;
+}
+function composeAbortSignals(external, internal) {
+  if (!external) return internal;
+  if (external.aborted) return external;
+  const controller = new AbortController();
+  const onAbort = (signal) => () => {
+    controller.abort(signal.reason);
+  };
+  external.addEventListener("abort", onAbort(external), { once: true });
+  internal.addEventListener("abort", onAbort(internal), { once: true });
+  return controller.signal;
+}
+async function fetchWithRetry(input, init = {}) {
+  const timeoutMs = init.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = init.retries ?? DEFAULT_RETRIES;
+  const { timeoutMs: _t, retries: _r, signal: externalSignal, ...rest } = init;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (externalSignal?.aborted) {
+      throw externalSignal.reason instanceof Error ? externalSignal.reason : new DOMException("Aborted", "AbortError");
+    }
+    const timeoutController = new AbortController();
+    const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const signal = composeAbortSignals(externalSignal, timeoutController.signal);
+    try {
+      const response = await fetch(input, { ...rest, signal });
+      clearTimeout(timer);
+      if (response.status === 429) {
+        throw new MoviieRateLimitError();
+      }
+      if (response.status >= 500 && response.status < 600 && attempt < maxRetries) {
+        await delay(backoffDelayMs(attempt));
+        continue;
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timer);
+      lastError = error;
+      if (error instanceof MoviieRateLimitError) throw error;
+      if (externalSignal?.aborted) {
+        throw externalSignal.reason instanceof Error ? externalSignal.reason : new DOMException("Aborted", "AbortError");
+      }
+      const isAbort = error instanceof Error && error.name === "AbortError";
+      if (isAbort && attempt < maxRetries) {
+        await delay(backoffDelayMs(attempt));
+        continue;
+      }
+      if (attempt >= maxRetries) {
+        throw new MoviieNetworkError();
+      }
+      await delay(backoffDelayMs(attempt));
+    }
+  }
+  throw lastError instanceof Error ? lastError : new MoviieNetworkError();
+}
+
+// src/client/client-headers.ts
+var SEPARATOR = ";";
+function sanitizeSegment(value) {
+  return value.replace(/[\r\n;]/g, "").trim();
+}
+function buildClientHeaders(params) {
+  const headers = {};
+  const key = params.publishableKey?.trim();
+  if (key) {
+    headers.Authorization = `Bearer ${key}`;
+  }
+  const info = params.clientInfo;
+  if (info) {
+    const parts = [];
+    if (info.bundleId) {
+      parts.push(`bundle_id=${sanitizeSegment(info.bundleId)}`);
+    }
+    parts.push(`platform=${sanitizeSegment(info.platform)}`);
+    const sdk = params.sdkVersion ?? info.sdkVersion;
+    if (sdk) {
+      parts.push(`sdk=${sanitizeSegment(sdk)}`);
+    }
+    headers["X-Moviie-Client"] = parts.join(SEPARATOR);
+  }
+  return headers;
+}
+var playbackPayloadSchema = zod.z.object({
+  uri: zod.z.string().url(),
+  contentType: zod.z.enum(["hls", "progressive"]),
+  expiresAt: zod.z.string().nullable(),
+  refreshAfter: zod.z.string().nullable(),
+  requestHeaders: zod.z.record(zod.z.string()).optional()
+});
+var moviiePlaybackDataResponseSchema = zod.z.object({
+  embedId: zod.z.string(),
+  title: zod.z.string(),
+  smartProgressEnabled: zod.z.boolean(),
+  durationSeconds: zod.z.number().nullable(),
+  isVertical: zod.z.boolean(),
+  videoWidthPx: zod.z.number().int().positive().nullable(),
+  videoHeightPx: zod.z.number().int().positive().nullable(),
+  profile: zod.z.string(),
+  playback: playbackPayloadSchema,
+  posterUrl: zod.z.string().nullable(),
+  branding: zod.z.object({
+    primaryColor: zod.z.string().nullable(),
+    showWatermark: zod.z.boolean(),
+    organizationName: zod.z.string().nullable()
+  }),
+  telemetry: zod.z.object({
+    bootstrapUrl: zod.z.string().url()
+  })
+}).passthrough();
+async function fetchPlaybackData(params) {
+  const response = await fetchWithRetry(params.url, {
+    headers: params.headers,
+    signal: params.signal,
+    method: "GET"
+  });
+  const reason = response.headers.get(HTTP_HEADER_MOVIIE_REASON)?.toLowerCase();
+  if (response.status === 401) {
+    throw new MoviieAuthError();
+  }
+  if (response.status === 402) {
+    throw new MoviieSubscriptionInactiveError();
+  }
+  if (response.status === 404) {
+    throw new MoviieNotFoundError();
+  }
+  if (response.status === 403) {
+    if (reason === MOVIIE_BLOCK_REASON.BUNDLE) {
+      throw new MoviieBundleBlockedError();
+    }
+    throw new MoviieReferrerBlockedError();
+  }
+  if (response.status >= 500) {
+    throw new MoviieNetworkError();
+  }
+  if (!response.ok) {
+    throw new MoviieNotFoundError("N\xE3o foi poss\xEDvel carregar a reprodu\xE7\xE3o");
+  }
+  const json = await response.json();
+  const parsed = moviiePlaybackDataResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new MoviieNotFoundError("Resposta de playback inv\xE1lida");
+  }
+  return parsed.data;
+}
+
+// src/client/moviie-client.ts
+var videoEmbedResponseSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  embed_id: zod.z.string().uuid()
+});
+var MoviieClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  headers(extra) {
+    return {
+      ...buildClientHeaders({
+        publishableKey: this.options.publishableKey ?? void 0,
+        clientInfo: this.options.clientInfo ?? void 0,
+        sdkVersion: this.options.sdkVersion
+      }),
+      ...extra
+    };
+  }
+  async getPlayback(embedId, signal) {
+    const key = this.options.publishableKey?.trim();
+    if (!key) {
+      throw new MoviieAuthError(SDK_PLAYBACK_AUTH_ERROR_MESSAGE.KEY_REQUIRED);
+    }
+    if (!key.startsWith(SDK_PUBLIC_API_KEY_PREFIX_PUBLISHABLE)) {
+      throw new MoviieAuthError(SDK_PLAYBACK_AUTH_ERROR_MESSAGE.PRIVATE_KEY_FORBIDDEN);
+    }
+    const base = getMoviieApiBaseUrl().replace(/\/+$/, "");
+    const url = `${base}/embeds/${encodeURIComponent(embedId)}/playback`;
+    return fetchPlaybackData({
+      url,
+      headers: this.headers(),
+      signal
+    });
+  }
+  async getVideo(videoId, signal) {
+    const key = this.options.publishableKey?.trim();
+    if (!key) {
+      throw new MoviieAuthError("Chave de API obrigat\xF3ria para buscar v\xEDdeo por ID");
+    }
+    if (key.startsWith(SDK_PUBLIC_API_KEY_PREFIX_PUBLISHABLE)) {
+      throw new MoviieAuthError("Chave publishable n\xE3o pode listar v\xEDdeos administrativos");
+    }
+    const base = getMoviieApiBaseUrl().replace(/\/+$/, "");
+    const url = `${base}/videos/${encodeURIComponent(videoId)}`;
+    const response = await fetchWithRetry(url, {
+      method: "GET",
+      headers: this.headers(),
+      signal
+    });
+    if (response.status === 401 || response.status === 403) {
+      throw new MoviieAuthError();
+    }
+    if (response.status === 404) {
+      throw new MoviieNotFoundError();
+    }
+    if (response.status >= 500) {
+      throw new MoviieNetworkError();
+    }
+    if (!response.ok) {
+      throw new MoviieNotFoundError();
+    }
+    const json = await response.json();
+    const parsed = videoEmbedResponseSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new MoviieNotFoundError("Resposta de v\xEDdeo inv\xE1lida");
+    }
+    return {
+      id: parsed.data.id,
+      embedId: parsed.data.embed_id
+    };
+  }
+  async resolveEmbedIdFromVideoId(videoId, signal) {
+    const video = await this.getVideo(videoId, signal);
+    if (!video.embedId) {
+      throw new MoviieNotFoundError("Embed n\xE3o encontrado para este v\xEDdeo");
+    }
+    return video.embedId;
+  }
+  getEventsBaseUrl() {
+    return getMoviieEventsBaseUrl().replace(/\/+$/, "");
+  }
+};
+var PLAYBACK_EVENT_TYPE = {
+  SESSION_START: "session_start",
+  PLAY_START: "play_start",
+  PAUSE: "pause",
+  RESUME: "resume",
+  HEARTBEAT: "heartbeat",
+  ENDED: "ended",
+  CTA_CLICK: "cta_click",
+  ERROR: "error"
+};
+var PLAYBACK_EVENT_TYPE_VALUES = Object.values(PLAYBACK_EVENT_TYPE);
+var playbackEventTypeSchema = zod.z.enum(
+  PLAYBACK_EVENT_TYPE_VALUES
+);
+var TELEMETRY_TOKEN_CONFIG = {
+  INGEST_TOKEN_EXPIRY_SECONDS: 600,
+  REFRESH_TOKEN_EXPIRY_SECONDS: 86400,
+  REFRESH_BUFFER_SECONDS: 120
+};
+var HEARTBEAT_CONFIG = {
+  INTERVAL_SECONDS: 10,
+  WATCH_TIME_PER_HEARTBEAT_SECONDS: 10
+};
+var bootstrapResponseSchema = zod.z.object({
+  sessionId: zod.z.string().uuid(),
+  eventsIngestToken: zod.z.string(),
+  eventsRefreshToken: zod.z.string(),
+  ctaId: zod.z.string().optional()
+});
+var tokenRefreshRequestSchema = zod.z.object({
+  sessionId: zod.z.string().uuid(),
+  eventsRefreshToken: zod.z.string()
+});
+var tokenRefreshResponseSchema = zod.z.object({
+  eventsIngestToken: zod.z.string(),
+  expiresInSeconds: zod.z.number()
+});
+var playbackEventSchema = zod.z.object({
+  eventId: zod.z.string().uuid(),
+  sessionId: zod.z.string().uuid(),
+  eventType: playbackEventTypeSchema,
+  positionSeconds: zod.z.number().int().min(0).optional(),
+  ctaId: zod.z.string().optional(),
+  errorCode: zod.z.string().max(50).optional()
+});
+zod.z.object({
+  events: zod.z.array(playbackEventSchema).min(1).max(100),
+  ingestToken: zod.z.string().optional()
+});
+
+// src/telemetry/heartbeat-scheduler.ts
+var HeartbeatScheduler = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  timer = null;
+  paused = false;
+  start() {
+    if (this.timer) return;
+    const ms = Math.max(1e3, this.options.intervalSeconds * 1e3);
+    this.timer = setInterval(() => {
+      if (!this.paused) {
+        this.options.onTick();
+      }
+    }, ms);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  destroy() {
+    this.stop();
+  }
+};
+
+// src/telemetry/token-manager.ts
+var REFRESH_MIN_DELAY_MS = 5e3;
+var REFRESH_RETRY_BACKOFF_MS = [5e3, 15e3, 6e4];
+var TelemetryTokenManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  ingestToken = null;
+  refreshToken = null;
+  sessionId = null;
+  refreshTimer = null;
+  refreshFailureCount = 0;
+  getSessionId() {
+    return this.sessionId;
+  }
+  getIngestToken() {
+    return this.ingestToken;
+  }
+  async bootstrap(bootstrapUrl) {
+    const response = await fetchWithRetry(bootstrapUrl, {
+      method: "GET",
+      headers: this.options.defaultHeaders
+    });
+    if (!response.ok) {
+      throw new Error(`Bootstrap falhou: ${response.status}`);
+    }
+    const json = await response.json();
+    const parsed = bootstrapResponseSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new Error("Resposta de bootstrap inv\xE1lida");
+    }
+    this.sessionId = parsed.data.sessionId;
+    this.ingestToken = parsed.data.eventsIngestToken;
+    this.refreshToken = parsed.data.eventsRefreshToken;
+    const store = this.options.viewerTokenStore;
+    if (store && parsed.data.eventsRefreshToken) {
+      await store.set(parsed.data.eventsRefreshToken, TELEMETRY_TOKEN_CONFIG.REFRESH_TOKEN_EXPIRY_SECONDS);
+    }
+    this.refreshFailureCount = 0;
+    this.scheduleRefresh(TELEMETRY_TOKEN_CONFIG.INGEST_TOKEN_EXPIRY_SECONDS);
+    return parsed.data;
+  }
+  scheduleRefresh(expirySeconds) {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    const refreshUrl = `${this.options.eventsBaseUrl.replace(/\/+$/, "")}/token/refresh`;
+    const delayMs = (expirySeconds - TELEMETRY_TOKEN_CONFIG.REFRESH_BUFFER_SECONDS) * 1e3;
+    this.refreshTimer = setTimeout(() => {
+      void this.refresh(refreshUrl);
+    }, Math.max(REFRESH_MIN_DELAY_MS, delayMs));
+  }
+  scheduleRefreshRetry() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    const refreshUrl = `${this.options.eventsBaseUrl.replace(/\/+$/, "")}/token/refresh`;
+    const index = Math.min(
+      this.refreshFailureCount,
+      REFRESH_RETRY_BACKOFF_MS.length - 1
+    );
+    const base = REFRESH_RETRY_BACKOFF_MS[index] ?? REFRESH_MIN_DELAY_MS;
+    const jitter = Math.floor(Math.random() * 1e3);
+    this.refreshTimer = setTimeout(() => {
+      void this.refresh(refreshUrl);
+    }, base + jitter);
+  }
+  async refresh(refreshUrl) {
+    if (!this.sessionId || !this.refreshToken) return;
+    const body = tokenRefreshRequestSchema.parse({
+      sessionId: this.sessionId,
+      eventsRefreshToken: this.refreshToken
+    });
+    try {
+      const response = await fetchWithRetry(refreshUrl, {
+        method: "POST",
+        headers: {
+          ...this.options.defaultHeaders,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        this.refreshFailureCount += 1;
+        this.scheduleRefreshRetry();
+        return;
+      }
+      const json = await response.json();
+      const parsed = tokenRefreshResponseSchema.safeParse(json);
+      if (!parsed.success) {
+        this.refreshFailureCount += 1;
+        this.scheduleRefreshRetry();
+        return;
+      }
+      this.ingestToken = parsed.data.eventsIngestToken;
+      this.refreshFailureCount = 0;
+      const nextExpiry = parsed.data.expiresInSeconds > 0 ? parsed.data.expiresInSeconds : TELEMETRY_TOKEN_CONFIG.INGEST_TOKEN_EXPIRY_SECONDS;
+      this.scheduleRefresh(nextExpiry);
+    } catch {
+      this.refreshFailureCount += 1;
+      this.scheduleRefreshRetry();
+    }
+  }
+  destroy() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+};
+
+// src/telemetry/telemetry-client.ts
+var BATCH_MAX = 10;
+var FLUSH_MS = 5e3;
+function randomHex(length) {
+  let out = "";
+  while (out.length < length) {
+    out += Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+  }
+  return out.slice(0, length);
+}
+function newEventId() {
+  const g = globalThis;
+  if (typeof g.crypto?.randomUUID === "function") {
+    return g.crypto.randomUUID();
+  }
+  return `${randomHex(8)}-${randomHex(4)}-4${randomHex(3)}-8${randomHex(3)}-${randomHex(12)}`;
+}
+var TelemetryClient = class {
+  constructor(options) {
+    this.options = options;
+    this.tokenManager = new TelemetryTokenManager({
+      eventsBaseUrl: options.eventsBaseUrl,
+      defaultHeaders: options.defaultHeaders,
+      viewerTokenStore: options.viewerTokenStore
+    });
+    this.heartbeat = new HeartbeatScheduler({
+      intervalSeconds: HEARTBEAT_CONFIG.INTERVAL_SECONDS,
+      onTick: () => {
+        const pos = typeof options.getPositionSeconds === "function" ? Math.floor(options.getPositionSeconds()) : this.positionSeconds;
+        void this.recordEvent({
+          eventType: PLAYBACK_EVENT_TYPE.HEARTBEAT,
+          positionSeconds: Math.max(0, pos)
+        });
+      }
+    });
+  }
+  options;
+  tokenManager;
+  heartbeat;
+  pending = [];
+  flushTimer = null;
+  positionSeconds = 0;
+  async bootstrap(params) {
+    const res = await this.tokenManager.bootstrap(params.bootstrapUrl);
+    return { sessionId: res.sessionId };
+  }
+  updatePosition(seconds) {
+    this.positionSeconds = Math.max(0, seconds);
+  }
+  async recordEvent(params) {
+    const sessionId = this.tokenManager.getSessionId();
+    if (!sessionId) return;
+    const payload = {
+      eventId: newEventId(),
+      sessionId,
+      eventType: params.eventType
+    };
+    if (params.positionSeconds !== void 0) {
+      payload.positionSeconds = params.positionSeconds;
+    }
+    if (params.ctaId !== void 0) {
+      payload.ctaId = params.ctaId;
+    }
+    if (params.errorCode !== void 0) {
+      payload.errorCode = params.errorCode;
+    }
+    this.pending.push(payload);
+    if (this.pending.length >= BATCH_MAX) {
+      await this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flush();
+    }, FLUSH_MS);
+  }
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.pending.length === 0) {
+      return;
+    }
+    const ingestToken = this.tokenManager.getIngestToken();
+    const sessionId = this.tokenManager.getSessionId();
+    if (!ingestToken || !sessionId) {
+      this.scheduleFlush();
+      return;
+    }
+    const batch = this.pending.splice(0, BATCH_MAX);
+    const eventsUrl = `${this.options.eventsBaseUrl.replace(/\/+$/, "")}/events`;
+    try {
+      const response = await fetchWithRetry(eventsUrl, {
+        method: "POST",
+        headers: {
+          ...this.options.defaultHeaders,
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${ingestToken}`
+        },
+        body: JSON.stringify({ events: batch })
+      });
+      if (!response.ok && response.status >= 500) {
+        this.pending.unshift(...batch);
+      }
+    } catch {
+      this.pending.unshift(...batch);
+    }
+    if (this.pending.length > 0) {
+      this.scheduleFlush();
+    }
+  }
+  startHeartbeats() {
+    this.heartbeat.start();
+  }
+  stopHeartbeats() {
+    this.heartbeat.stop();
+  }
+  pauseHeartbeats() {
+    this.heartbeat.pause();
+  }
+  resumeHeartbeats() {
+    this.heartbeat.resume();
+  }
+  async destroy() {
+    this.heartbeat.destroy();
+    this.tokenManager.destroy();
+    await this.flush();
+  }
+};
+
+// src/telemetry/viewer-token-store.ts
+var MemoryViewerTokenStore = class {
+  value = null;
+  async get() {
+    return this.value;
+  }
+  async set(token, _ttlSec) {
+    this.value = token;
+  }
+};
+
+// src/playback/playback-refresh.ts
+var REFRESH_BUFFER_MS = 6e4;
+function planRefresh(params) {
+  const { expiresAt, refreshAfter } = params.playback;
+  if (!expiresAt && !refreshAfter) {
+    return null;
+  }
+  const anchorIso = refreshAfter ?? expiresAt;
+  if (!anchorIso) return null;
+  const anchor = Date.parse(anchorIso);
+  if (!Number.isFinite(anchor)) return null;
+  const target = anchor - REFRESH_BUFFER_MS;
+  const delayMs = Math.max(0, target - params.now.getTime());
+  return { delayMs };
+}
+
+// src/config/telemetry-bootstrap-url.ts
+var BOOTSTRAP_SEGMENT_PATTERN = /\/bootstrap\/[^/]+\/?$/i;
+var TELEMETRY_PATH_MARKER = "/telemetry";
+function deriveTelemetryEventsBaseUrlFromBootstrapUrl(bootstrapUrl) {
+  try {
+    const u = new URL(bootstrapUrl);
+    const stripped = u.pathname.replace(BOOTSTRAP_SEGMENT_PATTERN, "");
+    if (!stripped.includes(TELEMETRY_PATH_MARKER)) {
+      return null;
+    }
+    const normalizedPath = stripped.replace(/\/+$/, "") || "/";
+    return `${u.origin}${normalizedPath}`;
+  } catch {
+    return null;
+  }
+}
+
+Object.defineProperty(exports, "PLAYER_API_EVENTS", {
+  enumerable: true,
+  get: function () { return playerTypes.PLAYER_API_EVENTS; }
+});
+exports.HEARTBEAT_CONFIG = HEARTBEAT_CONFIG;
+exports.MOVIIE_CDN_BASE = MOVIIE_CDN_BASE;
+exports.MOVIIE_DEFAULT_API_BASE_URL = MOVIIE_DEFAULT_API_BASE_URL;
+exports.MOVIIE_TELEMETRY_API_PATH_PREFIX = MOVIIE_TELEMETRY_API_PATH_PREFIX;
+exports.MOVIIE_WATCH_BASE = MOVIIE_WATCH_BASE;
+exports.MemoryViewerTokenStore = MemoryViewerTokenStore;
+exports.MoviieAuthError = MoviieAuthError;
+exports.MoviieBundleBlockedError = MoviieBundleBlockedError;
+exports.MoviieClient = MoviieClient;
+exports.MoviieNetworkError = MoviieNetworkError;
+exports.MoviieNotFoundError = MoviieNotFoundError;
+exports.MoviieRateLimitError = MoviieRateLimitError;
+exports.MoviieReferrerBlockedError = MoviieReferrerBlockedError;
+exports.MoviieSubscriptionInactiveError = MoviieSubscriptionInactiveError;
+exports.PLAYBACK_EVENT_TYPE = PLAYBACK_EVENT_TYPE;
+exports.SDK_PLAYBACK_AUTH_ERROR_MESSAGE = SDK_PLAYBACK_AUTH_ERROR_MESSAGE;
+exports.SDK_PUBLIC_API_KEY_PREFIX_PUBLISHABLE = SDK_PUBLIC_API_KEY_PREFIX_PUBLISHABLE;
+exports.TELEMETRY_TOKEN_CONFIG = TELEMETRY_TOKEN_CONFIG;
+exports.TelemetryClient = TelemetryClient;
+exports.buildClientHeaders = buildClientHeaders;
+exports.configureMoviieEndpoints = configureMoviieEndpoints;
+exports.deriveMoviieTelemetryBaseUrlFromApiBaseUrl = deriveMoviieTelemetryBaseUrlFromApiBaseUrl;
+exports.deriveTelemetryEventsBaseUrlFromBootstrapUrl = deriveTelemetryEventsBaseUrlFromBootstrapUrl;
+exports.fetchPlaybackData = fetchPlaybackData;
+exports.getMoviieApiBaseUrl = getMoviieApiBaseUrl;
+exports.getMoviieEventsBaseUrl = getMoviieEventsBaseUrl;
+exports.planRefresh = planRefresh;
+exports.resetMoviieEndpointsConfiguration = resetMoviieEndpointsConfiguration;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map