streamit-player 1.0.0

package/dist/core/index.cjs

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const PlayerController = require("../PlayerController-Bt7Po42U.cjs");
+class DrmValidator {
+  /**
+   * Performs an automated validation of the player's DRM state.
+   */
+  static async validate(controller) {
+    const report = {
+      emeSupported: typeof navigator !== "undefined" && typeof navigator.requestMediaKeySystemAccess === "function",
+      keySystems: {},
+      activeSystem: null,
+      hasMediaKeys: false,
+      activeSessionsCount: 0,
+      sessionIds: [],
+      keyStatuses: [],
+      hasUsableKey: false,
+      errors: [],
+      passed: false,
+      requestMediaKeySystemAccessChecked: false,
+      mediaKeysCreatedChecked: false,
+      mediaKeysAttachedChecked: false,
+      encryptedEventCount: 0,
+      licenseChallengeGeneratedCount: 0,
+      licenseRequestSentCount: 0,
+      licenseResponseReceivedCount: 0,
+      sessionUpdatedCount: 0,
+      keyStatusesChangeCount: 0,
+      usableKeysCount: 0,
+      expiredKeysCount: 0,
+      outputRestrictedCount: 0,
+      internalErrorsCount: 0,
+      closedSessionsCount: 0,
+      lastInternalError: null
+    };
+    if (!report.emeSupported) {
+      report.errors.push("EME is not supported on this platform/browser.");
+      return report;
+    }
+    const systems = {
+      widevine: "com.widevine.alpha",
+      playready: "com.microsoft.playready",
+      fairplay: "com.apple.fps",
+      clearkey: "org.w3.clearkey"
+    };
+    const videoCapabilities = [
+      { contentType: 'video/mp4; codecs="avc1.640028"' },
+      { contentType: 'video/mp4; codecs="avc1.4d401e"' },
+      { contentType: "video/mp4" },
+      { contentType: 'video/webm; codecs="vp9"' }
+    ];
+    const audioCapabilities = [
+      { contentType: 'audio/mp4; codecs="mp4a.40.2"' },
+      { contentType: "audio/mp4" },
+      { contentType: 'audio/webm; codecs="opus"' }
+    ];
+    for (const [name, sys] of Object.entries(systems)) {
+      try {
+        const config = [
+          // 1. Preferred full capabilities
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities,
+            audioCapabilities
+          },
+          // 2. Video fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities
+          },
+          // 3. Audio fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            audioCapabilities
+          },
+          // 4. State/Identifier disabled fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities,
+            persistentState: "not-allowed",
+            distinctiveIdentifier: "not-allowed"
+          }
+        ];
+        await navigator.requestMediaKeySystemAccess(sys, config);
+        report.keySystems[name] = true;
+      } catch (_) {
+        report.keySystems[name] = false;
+      }
+    }
+    const video = controller.getVideoElement();
+    if (video) {
+      if (video.mediaKeys) {
+        report.hasMediaKeys = true;
+        const drmManager = controller.getDrmManager();
+        if (drmManager) {
+          const drmConfig = drmManager.getConfig();
+          if (drmConfig) {
+            report.activeSystem = Object.keys(drmConfig).find(
+              (k) => k !== "robustness" && k !== "distinctiveIdentifier" && k !== "persistentState" && k !== "retryCount" && k !== "timeout"
+            ) || null;
+          }
+          const sessions = drmManager.getActiveSessions();
+          if (sessions) {
+            report.activeSessionsCount = sessions.size;
+            sessions.forEach((s) => {
+              if (s.sessionId) {
+                report.sessionIds.push(s.sessionId);
+              }
+              if (s.keyStatuses) {
+                s.keyStatuses.forEach((status) => {
+                  report.keyStatuses.push(String(status));
+                  if (status === "usable") {
+                    report.hasUsableKey = true;
+                  }
+                });
+              }
+            });
+          }
+          const diag = drmManager.emeDiagnostics;
+          if (diag) {
+            report.requestMediaKeySystemAccessChecked = diag.requestMediaKeySystemAccess;
+            report.mediaKeysCreatedChecked = diag.mediaKeysCreated;
+            report.mediaKeysAttachedChecked = diag.mediaKeysAttached;
+            report.encryptedEventCount = diag.encryptedEventsCount;
+            report.licenseChallengeGeneratedCount = diag.challengesGenerated;
+            report.licenseRequestSentCount = diag.licenseRequestsSent;
+            report.licenseResponseReceivedCount = diag.licenseResponsesReceived;
+            report.sessionUpdatedCount = diag.sessionsUpdated;
+            report.keyStatusesChangeCount = diag.keyStatusesChanges;
+            report.usableKeysCount = diag.usableKeysCount;
+            report.expiredKeysCount = diag.expiredKeysCount;
+            report.outputRestrictedCount = diag.outputRestrictedCount;
+            report.internalErrorsCount = diag.internalErrorsCount;
+            report.closedSessionsCount = diag.closedSessionsCount;
+            report.lastInternalError = diag.lastInternalError;
+            if (diag.expiredKeysCount > 0) {
+              report.errors.push(`EME has ${diag.expiredKeysCount} expired key(s).`);
+            }
+            if (diag.outputRestrictedCount > 0) {
+              report.errors.push(`EME playback restricted by HDCP output constraints.`);
+            }
+            if (diag.internalErrorsCount > 0 && diag.lastInternalError) {
+              report.errors.push(`EME Internal Error: ${diag.lastInternalError}`);
+            }
+          }
+        }
+      }
+    }
+    const state = controller.getState();
+    if (state && state.error) {
+      report.errors.push(state.error);
+    }
+    report.passed = report.emeSupported && report.errors.length === 0;
+    return report;
+  }
+}
+exports.AdBreakManager = PlayerController.AdBreakManager;
+exports.AdBreakType = PlayerController.AdBreakType;
+exports.AdErrorType = PlayerController.AdErrorType;
+exports.AdPlacementType = PlayerController.AdPlacementType;
+exports.AdProviderType = PlayerController.AdProviderType;
+exports.AdSkipMode = PlayerController.AdSkipMode;
+exports.AdState = PlayerController.AdState;
+exports.AdsController = PlayerController.AdsController;
+exports.AdsManager = PlayerController.AdsManager;
+exports.AdsValidator = PlayerController.AdsValidator;
+exports.AutoThumbnailProvider = PlayerController.AutoThumbnailProvider;
+exports.DrmManager = PlayerController.DrmManager;
+exports.HtmlOverlayRenderer = PlayerController.HtmlOverlayRenderer;
+exports.ImaProvider = PlayerController.ImaProvider;
+exports.KeyboardManager = PlayerController.KeyboardManager;
+exports.PlayerController = PlayerController.PlayerController;
+exports.SimidBridge = PlayerController.SimidBridge;
+exports.SimidErrorCode = PlayerController.SimidErrorCode;
+exports.SimidManager = PlayerController.SimidManager;
+exports.SimidRuntime = PlayerController.SimidRuntime;
+exports.SimidSession = PlayerController.SimidSession;
+exports.SpriteThumbnailProvider = PlayerController.SpriteThumbnailProvider;
+exports.TimelineMath = PlayerController.TimelineMath;
+exports.TrackingEventName = PlayerController.TrackingEventName;
+exports.VTTThumbnailProvider = PlayerController.VTTThumbnailProvider;
+exports.VastProvider = PlayerController.VastProvider;
+exports.VideoFrameThumbnailProvider = PlayerController.VideoFrameThumbnailProvider;
+exports.VmapProvider = PlayerController.VmapProvider;
+exports.detectSupportedKeySystems = PlayerController.detectSupportedKeySystems;
+exports.formatTime = PlayerController.formatTime;
+exports.isClearKeySupported = PlayerController.isClearKeySupported;
+exports.isFairPlaySupported = PlayerController.isFairPlaySupported;
+exports.isKeySystemSupported = PlayerController.isKeySystemSupported;
+exports.isPlayReadySupported = PlayerController.isPlayReadySupported;
+exports.isWidevineSupported = PlayerController.isWidevineSupported;
+exports.normalizeClearKeyValue = PlayerController.normalizeClearKeyValue;
+exports.normalizeClearKeys = PlayerController.normalizeClearKeys;
+exports.DrmValidator = DrmValidator;

package/dist/core/index.js

@@ -0,0 +1,194 @@
+import { A, a, b, c, d, e, f, g, h, i, j, D, H, I, K, P, S, k, l, m, n, o, T, p, V, q, r, s, t, u, v, w, x, y, z, B, C } from "../PlayerController-CW0pxrIt.js";
+class DrmValidator {
+  /**
+   * Performs an automated validation of the player's DRM state.
+   */
+  static async validate(controller) {
+    const report = {
+      emeSupported: typeof navigator !== "undefined" && typeof navigator.requestMediaKeySystemAccess === "function",
+      keySystems: {},
+      activeSystem: null,
+      hasMediaKeys: false,
+      activeSessionsCount: 0,
+      sessionIds: [],
+      keyStatuses: [],
+      hasUsableKey: false,
+      errors: [],
+      passed: false,
+      requestMediaKeySystemAccessChecked: false,
+      mediaKeysCreatedChecked: false,
+      mediaKeysAttachedChecked: false,
+      encryptedEventCount: 0,
+      licenseChallengeGeneratedCount: 0,
+      licenseRequestSentCount: 0,
+      licenseResponseReceivedCount: 0,
+      sessionUpdatedCount: 0,
+      keyStatusesChangeCount: 0,
+      usableKeysCount: 0,
+      expiredKeysCount: 0,
+      outputRestrictedCount: 0,
+      internalErrorsCount: 0,
+      closedSessionsCount: 0,
+      lastInternalError: null
+    };
+    if (!report.emeSupported) {
+      report.errors.push("EME is not supported on this platform/browser.");
+      return report;
+    }
+    const systems = {
+      widevine: "com.widevine.alpha",
+      playready: "com.microsoft.playready",
+      fairplay: "com.apple.fps",
+      clearkey: "org.w3.clearkey"
+    };
+    const videoCapabilities = [
+      { contentType: 'video/mp4; codecs="avc1.640028"' },
+      { contentType: 'video/mp4; codecs="avc1.4d401e"' },
+      { contentType: "video/mp4" },
+      { contentType: 'video/webm; codecs="vp9"' }
+    ];
+    const audioCapabilities = [
+      { contentType: 'audio/mp4; codecs="mp4a.40.2"' },
+      { contentType: "audio/mp4" },
+      { contentType: 'audio/webm; codecs="opus"' }
+    ];
+    for (const [name, sys] of Object.entries(systems)) {
+      try {
+        const config = [
+          // 1. Preferred full capabilities
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities,
+            audioCapabilities
+          },
+          // 2. Video fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities
+          },
+          // 3. Audio fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            audioCapabilities
+          },
+          // 4. State/Identifier disabled fallback
+          {
+            initDataTypes: ["cenc", "keyids", "webm", "skd", "sinf"],
+            videoCapabilities,
+            persistentState: "not-allowed",
+            distinctiveIdentifier: "not-allowed"
+          }
+        ];
+        await navigator.requestMediaKeySystemAccess(sys, config);
+        report.keySystems[name] = true;
+      } catch (_) {
+        report.keySystems[name] = false;
+      }
+    }
+    const video = controller.getVideoElement();
+    if (video) {
+      if (video.mediaKeys) {
+        report.hasMediaKeys = true;
+        const drmManager = controller.getDrmManager();
+        if (drmManager) {
+          const drmConfig = drmManager.getConfig();
+          if (drmConfig) {
+            report.activeSystem = Object.keys(drmConfig).find(
+              (k2) => k2 !== "robustness" && k2 !== "distinctiveIdentifier" && k2 !== "persistentState" && k2 !== "retryCount" && k2 !== "timeout"
+            ) || null;
+          }
+          const sessions = drmManager.getActiveSessions();
+          if (sessions) {
+            report.activeSessionsCount = sessions.size;
+            sessions.forEach((s2) => {
+              if (s2.sessionId) {
+                report.sessionIds.push(s2.sessionId);
+              }
+              if (s2.keyStatuses) {
+                s2.keyStatuses.forEach((status) => {
+                  report.keyStatuses.push(String(status));
+                  if (status === "usable") {
+                    report.hasUsableKey = true;
+                  }
+                });
+              }
+            });
+          }
+          const diag = drmManager.emeDiagnostics;
+          if (diag) {
+            report.requestMediaKeySystemAccessChecked = diag.requestMediaKeySystemAccess;
+            report.mediaKeysCreatedChecked = diag.mediaKeysCreated;
+            report.mediaKeysAttachedChecked = diag.mediaKeysAttached;
+            report.encryptedEventCount = diag.encryptedEventsCount;
+            report.licenseChallengeGeneratedCount = diag.challengesGenerated;
+            report.licenseRequestSentCount = diag.licenseRequestsSent;
+            report.licenseResponseReceivedCount = diag.licenseResponsesReceived;
+            report.sessionUpdatedCount = diag.sessionsUpdated;
+            report.keyStatusesChangeCount = diag.keyStatusesChanges;
+            report.usableKeysCount = diag.usableKeysCount;
+            report.expiredKeysCount = diag.expiredKeysCount;
+            report.outputRestrictedCount = diag.outputRestrictedCount;
+            report.internalErrorsCount = diag.internalErrorsCount;
+            report.closedSessionsCount = diag.closedSessionsCount;
+            report.lastInternalError = diag.lastInternalError;
+            if (diag.expiredKeysCount > 0) {
+              report.errors.push(`EME has ${diag.expiredKeysCount} expired key(s).`);
+            }
+            if (diag.outputRestrictedCount > 0) {
+              report.errors.push(`EME playback restricted by HDCP output constraints.`);
+            }
+            if (diag.internalErrorsCount > 0 && diag.lastInternalError) {
+              report.errors.push(`EME Internal Error: ${diag.lastInternalError}`);
+            }
+          }
+        }
+      }
+    }
+    const state = controller.getState();
+    if (state && state.error) {
+      report.errors.push(state.error);
+    }
+    report.passed = report.emeSupported && report.errors.length === 0;
+    return report;
+  }
+}
+export {
+  A as AdBreakManager,
+  a as AdBreakType,
+  b as AdErrorType,
+  c as AdPlacementType,
+  d as AdProviderType,
+  e as AdSkipMode,
+  f as AdState,
+  g as AdsController,
+  h as AdsManager,
+  i as AdsValidator,
+  j as AutoThumbnailProvider,
+  D as DrmManager,
+  DrmValidator,
+  H as HtmlOverlayRenderer,
+  I as ImaProvider,
+  K as KeyboardManager,
+  P as PlayerController,
+  S as SimidBridge,
+  k as SimidErrorCode,
+  l as SimidManager,
+  m as SimidRuntime,
+  n as SimidSession,
+  o as SpriteThumbnailProvider,
+  T as TimelineMath,
+  p as TrackingEventName,
+  V as VTTThumbnailProvider,
+  q as VastProvider,
+  r as VideoFrameThumbnailProvider,
+  s as VmapProvider,
+  t as detectSupportedKeySystems,
+  u as formatTime,
+  v as isClearKeySupported,
+  w as isFairPlaySupported,
+  x as isKeySystemSupported,
+  y as isPlayReadySupported,
+  z as isWidevineSupported,
+  B as normalizeClearKeyValue,
+  C as normalizeClearKeys
+};

package/dist/core/src/AdScheduler.d.ts

@@ -0,0 +1,56 @@
+import { PlayerController } from './PlayerController';
+import { AdProvider, Advertisement, HtmlOverlayConfig } from './types';
+
+export interface ScheduledAdRequest {
+    /** Required for provider 'VAST' | 'IMA'. Ignored for 'HTML_OVERLAY'. */
+    tagUrl?: string;
+    type: 'preroll' | 'midroll' | 'postroll';
+    /** Seconds (number), or a percentage of content duration, e.g. '50%'. Only used for 'midroll'. */
+    timeOffset?: number | string;
+    /** Which registered provider to trigger. Defaults to 'VAST'. */
+    provider?: 'VAST' | 'IMA' | 'HTML_OVERLAY';
+    /** Required for provider 'HTML_OVERLAY' - the overlay creative to show when this break hits. */
+    overlay?: Advertisement | HtmlOverlayConfig;
+}
+/**
+ * Resolves a midroll timeOffset to absolute seconds. Numbers pass through
+ * unchanged. Percentage strings (e.g. '50%') resolve against duration once
+ * it's known; returns null if not yet resolvable (duration unknown) or the
+ * format is invalid - callers should treat null as "try again later".
+ */
+export declare function resolveScheduledTimeOffset(timeOffset: number | string | undefined, duration: number): number | null;
+export declare function evaluateScheduledHits(breaks: Array<{
+    id: string;
+    type: 'preroll' | 'midroll' | 'postroll';
+    timeOffset?: number;
+    isPlayed: boolean;
+}>, currentTime: number, duration: number, isEnded: boolean): string[];
+/**
+ * NOTE: AdScheduler and VmapProvider both independently watch the video
+ * element's timeupdate/ended events with no shared coordination or
+ * frequency-cap state between them. Using player.ads.schedule() alongside
+ * a VMAP playlist on the same player instance is unsupported - pick one
+ * scheduling mechanism per player instance.
+ */
+export declare class AdScheduler {
+    private controller;
+    private getProviderByName;
+    private showOverlay;
+    private breaks;
+    private timeUpdateListener;
+    private endedListener;
+    private nextId;
+    constructor(controller: PlayerController, getProviderByName: (name: 'VAST' | 'IMA') => AdProvider | undefined, showOverlay: (config: Advertisement | HtmlOverlayConfig) => Promise<boolean>);
+    schedule(request: ScheduledAdRequest): string;
+    /** True if there are unplayed manually-scheduled breaks - used to detect
+     * the unsupported combination with an active VmapProvider playlist (see
+     * class-level note above). */
+    hasActiveBreaks(): boolean;
+    unschedule(id: string): void;
+    clear(): void;
+    destroy(): void;
+    private attach;
+    private evaluate;
+    private trigger;
+}
+//# sourceMappingURL=AdScheduler.d.ts.map

package/dist/core/src/AdScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdScheduler.d.ts","sourceRoot":"","sources":["../../../core/src/AdScheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAe,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEpF,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;IACzC,kGAAkG;IAClG,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,cAAc,CAAC;IAC3C,gGAAgG;IAChG,OAAO,CAAC,EAAE,aAAa,GAAG,iBAAiB,CAAC;CAC7C;AAQD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACvC,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAYf;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,EAC/G,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,MAAM,EAAE,CAgBV;AAED;;;;;;GAMG;AACH,qBAAa,WAAW;IAOpB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,WAAW;IARrB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,MAAM,CAAK;gBAGT,UAAU,EAAE,gBAAgB,EAC5B,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,KAAK,UAAU,GAAG,SAAS,EACnE,WAAW,EAAE,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC;IAK/E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM;IAMpD;;kCAE8B;IACvB,eAAe,IAAI,OAAO;IAI1B,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B,KAAK,IAAI,IAAI;IAIb,OAAO,IAAI,IAAI;IAOtB,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,QAAQ;YAgCF,OAAO;CA0BtB"}

package/dist/core/src/AdsController.d.ts

@@ -0,0 +1,48 @@
+import { PlayerController } from './PlayerController';
+import { AdsManager } from './AdsManager';
+import { ScheduledAdRequest } from './AdScheduler';
+import { PlayerState, Advertisement, HtmlOverlayConfig, AdBreak, AdProvider, CapabilityInfo, AdsDiagnostics, AdsValidationReport } from './types';
+import { HtmlOverlayDiagnostics } from './html-overlay/HtmlOverlayRenderer';
+
+export declare class AdsController {
+    private controller;
+    readonly manager: AdsManager;
+    private providers;
+    private activeProviderName;
+    private adContainerElement;
+    constructor(controller: PlayerController);
+    setAdContainer(container: HTMLElement): void;
+    getAdContainer(): HTMLElement | null;
+    state(): Partial<PlayerState>;
+    provider(): string | null;
+    capabilities(): CapabilityInfo | null;
+    currentAd(): Advertisement | null;
+    currentBreak(): AdBreak | null;
+    skip(): void;
+    pause(): void;
+    resume(): void;
+    enable(): void;
+    disable(): void;
+    private scheduler;
+    private getScheduler;
+    schedule(request: ScheduledAdRequest): string;
+    /** True if there's an active manual schedule (via schedule()) with unplayed
+     * breaks - used by VmapProvider to detect the unsupported combination. */
+    hasActiveManualSchedule(): boolean;
+    unschedule(id: string): void;
+    clearSchedule(): void;
+    play(tagUrl: string): Promise<void>;
+    registerProvider(name: string, provider: AdProvider, adContainer?: HTMLElement): void;
+    initializeProvider(name: string, adContainer?: HTMLElement): boolean;
+    getProvider(name: string): AdProvider | undefined;
+    unregisterProvider(name: string): void;
+    destroy(): void;
+    showOverlay(adOrConfig: Advertisement | HtmlOverlayConfig): Promise<boolean>;
+    hideOverlay(): void;
+    closeOverlay(): void;
+    updateOverlay(patch: Partial<HtmlOverlayConfig>): void;
+    getOverlayDiagnostics(): HtmlOverlayDiagnostics | null;
+    diagnostics(): AdsDiagnostics;
+    validate(): AdsValidationReport;
+}
+//# sourceMappingURL=AdsController.d.ts.map

package/dist/core/src/AdsController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdsController.d.ts","sourceRoot":"","sources":["../../../core/src/AdsController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAe,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIhE,OAAO,EACL,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,UAAU,EACV,cAAc,EACd,cAAc,EACd,mBAAmB,EAIpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAmB;IACrC,SAAgB,OAAO,EAAE,UAAU,CAAC;IACpC,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,kBAAkB,CAA4B;gBAE1C,UAAU,EAAE,gBAAgB;IAWjC,cAAc,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI;IAU5C,cAAc,IAAI,WAAW,GAAG,IAAI;IAIpC,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;IAkB7B,QAAQ,IAAI,MAAM,GAAG,IAAI;IAIzB,YAAY,IAAI,cAAc,GAAG,IAAI;IAQrC,SAAS,IAAI,aAAa,GAAG,IAAI;IAIjC,YAAY,IAAI,OAAO,GAAG,IAAI;IAI9B,IAAI,IAAI,IAAI;IAIZ,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAId,MAAM,IAAI,IAAI;IAId,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,SAAS,CAA4B;IAE7C,OAAO,CAAC,YAAY;IAWb,QAAQ,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM;IAgBpD;8EAC0E;IACnE,uBAAuB,IAAI,OAAO;IAIlC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B,aAAa,IAAI,IAAI;IAIf,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASzC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAYrF,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO;IAgBpE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAuBjD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAiBtC,OAAO,IAAI,IAAI;IAKT,WAAW,CAAC,UAAU,EAAE,aAAa,GAAG,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlF,WAAW,IAAI,IAAI;IAInB,YAAY,IAAI,IAAI;IAIpB,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAItD,qBAAqB,IAAI,sBAAsB,GAAG,IAAI;IAKtD,WAAW,IAAI,cAAc;IAmB7B,QAAQ,IAAI,mBAAmB;CAGvC"}

package/dist/core/src/AdsManager.d.ts

@@ -0,0 +1,181 @@
+import { PlayerController } from './PlayerController';
+import { HtmlOverlayRenderer } from './html-overlay/HtmlOverlayRenderer';
+import { PlaybackInterceptor, PlayerPlugin, AdBreak, Advertisement, HtmlOverlayConfig, AdState, AdProvider, CapabilityInfo, ProviderContext, AdError, CompanionSlot, PlayerSource } from './types';
+
+export declare function matchCompanionsToSlots(companions: Advertisement[], slots: CompanionSlot[]): Array<{
+    slot: CompanionSlot;
+    companion: Advertisement;
+}>;
+export declare class ProviderManager {
+    private providers;
+    private activeProviderName;
+    registerProvider(name: string, provider: AdProvider): void;
+    getProvider(name: string): AdProvider | undefined;
+    unregisterProvider(name: string): void;
+    selectProvider(name: string | null): void;
+    getActiveProvider(): AdProvider | undefined;
+    getActiveProviderName(): string | null;
+    getCapabilities(name: string): CapabilityInfo | null;
+    onSourceLoaded(source?: PlayerSource): void;
+    destroy(): void;
+}
+export interface SnapshotState {
+    readonly currentTime: number;
+    readonly paused: boolean;
+    readonly playbackRate: number;
+    readonly muted: boolean;
+    readonly volume: number;
+    readonly activeAudioTrack: number;
+    readonly activeSubtitleTrackId: string | null;
+    readonly activeQuality: number;
+    readonly isFullscreen: boolean;
+    readonly pictureInPicture: boolean;
+    readonly isAtLiveEdge: boolean;
+    readonly liveLatency: number | null;
+}
+export declare class ContentSnapshot {
+    private snapshot;
+    capture(controller: PlayerController): void;
+    restore(controller: PlayerController): void;
+    clear(): void;
+    exists(): boolean;
+}
+export declare class AdBreakManager {
+    private activeBreak;
+    private pendingBreaks;
+    private completedBreaks;
+    private cancelledBreaks;
+    registerBreak(adBreak: AdBreak): void;
+    activateBreak(adBreak: AdBreak): void;
+    completeBreak(): void;
+    cancelBreak(id: string): void;
+    clearBreaks(): void;
+    getActiveBreak(): AdBreak | null;
+    getPendingBreaks(): AdBreak[];
+    getCompletedBreaks(): AdBreak[];
+    getCancelledBreaks(): AdBreak[];
+}
+export declare class AsyncGuard {
+    private activeToken;
+    generateToken(): number;
+    isValid(token: number): boolean;
+    invalidateAll(): void;
+}
+export declare class TimeoutManager {
+    private timers;
+    set(id: string, callback: () => void, delayMs: number): void;
+    clear(id: string): void;
+    clearAll(): void;
+}
+export interface ExtendedDiagnosticsStats {
+    totalAdsRequested: number;
+    totalAdsPlayed: number;
+    totalAdsCompleted: number;
+    totalAdsSkipped: number;
+    totalAdErrors: number;
+    recoveryCount: number;
+    timeoutCount: number;
+    cancelledAdsCount: number;
+    providerFailures: number;
+    averageLoadTimeMs: number;
+    averageResumeTimeMs: number;
+    activeOperationsCount: number;
+}
+export declare class AdsManager implements PlayerPlugin, PlaybackInterceptor {
+    readonly name = "ads-manager";
+    private controller;
+    private state;
+    private providerManager;
+    private contentSnapshot;
+    private adBreakManager;
+    private asyncGuard;
+    private timeoutManager;
+    private htmlOverlayRenderer;
+    private companionRenderers;
+    private concurrentOverlayRenderers;
+    private adContainer;
+    private isInterceptionActive;
+    private currentAd;
+    private requestedCount;
+    private playedCount;
+    private completedCount;
+    private skippedCount;
+    private errorCount;
+    private recoveryCount;
+    private timeoutCount;
+    private cancelledCount;
+    private providerFailuresCount;
+    private activeOperations;
+    install(controller: PlayerController): void;
+    destroy(): void;
+    getProviderManager(): ProviderManager;
+    getAdBreakManager(): AdBreakManager;
+    getAdState(): AdState;
+    getSavedContentSnapshot(): ContentSnapshot;
+    transitionTo(newState: AdState): boolean;
+    private updateDiagnosticsMetrics;
+    private dispatchStateEvents;
+    startAdBreak(adBreak: AdBreak, options?: {
+        skipVideoOwnership?: boolean;
+    }): void;
+    skipAd(): void;
+    endAdBreak(): void;
+    recover(reason: string): void;
+    triggerAdError(error: AdError): void;
+    scheduleTimeout(id: string, delayMs: number, reason: string): void;
+    cancelTimeout(id: string): void;
+    setAdContainer(container: HTMLElement): void;
+    getAdContainer(): HTMLElement | null;
+    createProviderContext(adContainer?: HTMLElement): ProviderContext;
+    setCurrentAd(ad: Advertisement | null): void;
+    private updatePlayerState;
+    play(): Promise<boolean> | boolean;
+    pause(): boolean;
+    seek(time: number): boolean;
+    setVolume(vol: number): boolean;
+    setMuted(muted: boolean): boolean;
+    private triggerLifecycleHook;
+    liveEdgeSyncHook(): void;
+    dvrPositionHook(): void;
+    catchUpPlaybackHook(): void;
+    liveSourceSwitchHook(): void;
+    playlistItemStartHook(): void;
+    playlistItemEndHook(): void;
+    autoplayNextItemHook(): void;
+    playlistRepeatHook(): void;
+    playlistNavigationHook(): void;
+    getHtmlOverlayRenderer(): HtmlOverlayRenderer | null;
+    private applyDefaultSanitizer;
+    isHtmlOverlayCreative(ad: Advertisement): boolean;
+    showCompanions(companions: Advertisement[]): void;
+    private clearCompanions;
+    /**
+     * Renders NonLinear overlay ads declared inside the SAME VAST <Ad> as the
+     * Linear creative currently playing - i.e. an overlay banner shown ON TOP
+     * of the ad video while it plays, per the standard IAB VAST pattern. Unlike
+     * `playHtmlOverlay()`, this does NOT touch `currentAd` or the AdState
+     * machine - it's a passive, fire-and-forget render alongside the Linear ad,
+     * exactly like `showCompanions()` except targeting the player container
+     * instead of an external page slot.
+     */
+    showConcurrentOverlays(nonLinearAds: Advertisement[]): void;
+    /**
+     * Clears both companion ads and concurrent NonLinear overlays. Providers
+     * call this before playing the next ad in a pod, so a previous ad's
+     * companion/overlay isn't left stuck on screen if the next ad has none of
+     * its own (showCompanions/showConcurrentOverlays only run when there IS
+     * something new to show, so a previous render would otherwise never clear).
+     */
+    clearAuxiliaryOverlays(): void;
+    private clearConcurrentOverlays;
+    private fireOverlayErrorPixels;
+    showOverlay(adOrConfig: Advertisement | HtmlOverlayConfig): Promise<boolean>;
+    hideOverlay(): void;
+    closeOverlay(): void;
+    updateOverlay(patch: Partial<HtmlOverlayConfig>): void;
+    playHtmlOverlay(ad: Advertisement): Promise<void>;
+    onSourceLoaded(source?: PlayerSource): void;
+    handleSourceSwitch(): void;
+    getDiagnosticsStats(): ExtendedDiagnosticsStats;
+}
+//# sourceMappingURL=AdsManager.d.ts.map