@eyevinn/player-analytics-client-sdk-web 0.2.0 → 0.4.0

package/dist/module.js

@@ -148,44 +148,81 @@ var $1d47cc84225ea891$var$__generator = undefined && undefined.__generator || fu
         return this;
     }), g;
 };
+var $1d47cc84225ea891$var$MAX_QUEUE_SIZE = 100;
 var $1d47cc84225ea891$export$957313a2f485e5ed = function() {
     function $1d47cc84225ea891$export$957313a2f485e5ed(options) {
-        this.isInitiated = false;
-        this.debug = options.debug;
+        var _a;
+        this.state = "idle";
+        this.eventQueue = [];
+        this.initPromise = null;
+        this.debug = (_a = options.debug) !== null && _a !== void 0 ? _a : false;
+        this.shardId = options.shardId;
         this.eventsinkUrl = options.eventsinkUrl;
         this.sessionId = options.sessionId;
         this.heartbeatInterval = options.heartbeatInterval || $76abaee2435acae3$export$31c453b5fe09788d;
+        this.onError = options.onError;
         if (this.debug) console.log("[AnalyticsReporter] Initiated AnalyticsReporter", options);
     }
+    Object.defineProperty($1d47cc84225ea891$export$957313a2f485e5ed.prototype, "isInitiated", {
+        get: function() {
+            return this.state === "ready";
+        },
+        enumerable: false,
+        configurable: true
+    });
     $1d47cc84225ea891$export$957313a2f485e5ed.prototype.init = function(sessionId) {
         return $1d47cc84225ea891$var$__awaiter(this, void 0, Promise, function() {
-            var data, initResponse, initResponseJson;
+            var data, result;
+            return $1d47cc84225ea891$var$__generator(this, function(_a) {
+                if (this.state !== "idle") return [
+                    2 /*return*/ ,
+                    this.initPromise
+                ];
+                this.sessionId = sessionId || this.sessionId;
+                this.state = "initializing";
+                data = {
+                    event: "init",
+                    sessionId: this.sessionId,
+                    shardId: this.shardId,
+                    timestamp: Date.now(),
+                    playhead: -1,
+                    duration: -1
+                };
+                if (this.debug) {
+                    console.log("[AnalyticsReporter] Init session:", data);
+                    this.state = "ready";
+                    this.flushQueue();
+                    result = {
+                        sessionId: this.sessionId,
+                        heartbeatInterval: this.heartbeatInterval,
+                        isInitiated: true
+                    };
+                    this.initPromise = Promise.resolve(result);
+                    return [
+                        2 /*return*/ ,
+                        this.initPromise
+                    ];
+                }
+                this.initPromise = this.doInit(data);
+                return [
+                    2 /*return*/ ,
+                    this.initPromise
+                ];
+            });
+        });
+    };
+    $1d47cc84225ea891$export$957313a2f485e5ed.prototype.doInit = function(data) {
+        return $1d47cc84225ea891$var$__awaiter(this, void 0, Promise, function() {
+            var initResponse, initResponseJson, err_1;
             return $1d47cc84225ea891$var$__generator(this, function(_a) {
                 switch(_a.label){
                     case 0:
-                        this.sessionId = sessionId || this.sessionId;
-                        data = {
-                            event: "init",
-                            sessionId: this.sessionId,
-                            timestamp: Date.now(),
-                            playhead: -1,
-                            duration: -1
-                        };
-                        if (!this.debug) return [
-                            3 /*break*/ ,
-                            1
-                        ];
-                        console.log("[AnalyticsReporter] Init session:", data);
-                        this.isInitiated = true;
-                        return [
-                            2 /*return*/ ,
-                            {
-                                sessionId: this.sessionId,
-                                heartbeatInterval: this.heartbeatInterval,
-                                isInitiated: this.isInitiated
-                            }
-                        ];
-                    case 1:
+                        _a.trys.push([
+                            0,
+                            6,
+                            ,
+                            7
+                        ]);
                         return [
                             4 /*yield*/ ,
                             fetch("".concat(this.eventsinkUrl), {
@@ -200,37 +237,150 @@ var $1d47cc84225ea891$export$957313a2f485e5ed = function() {
                                 body: JSON.stringify(data)
                             })
                         ];
-                    case 2:
+                    case 1:
                         initResponse = _a.sent();
+                        // Abort if destroy() was called during the await
+                        if (this.state === "destroyed") throw new Error("[AnalyticsReporter] init aborted: reporter was destroyed");
                         if (!initResponse.ok) throw new Error("[AnalyticsReporter] init failed: ".concat(initResponse.statusText));
                         return [
                             4 /*yield*/ ,
                             initResponse.json()
                         ];
-                    case 3:
+                    case 2:
                         initResponseJson = _a.sent();
+                        if (this.state === "destroyed") throw new Error("[AnalyticsReporter] init aborted: reporter was destroyed");
                         if (!this.sessionId && !initResponseJson.sessionId) throw new Error("[AnalyticsReporter] init failed: no sessionId");
                         if (initResponseJson.sessionId) this.sessionId = initResponseJson.sessionId;
-                        this.isInitiated = true;
+                        _a.label = 3;
+                    case 3:
+                        if (!(this.eventQueue.length > 0)) return [
+                            3 /*break*/ ,
+                            5
+                        ];
+                        if (this.state === "destroyed") throw new Error("[AnalyticsReporter] init aborted: reporter was destroyed");
+                        return [
+                            4 /*yield*/ ,
+                            this.flushQueue()
+                        ];
+                    case 4:
+                        _a.sent();
+                        return [
+                            3 /*break*/ ,
+                            3
+                        ];
+                    case 5:
+                        // Don't transition to ready if destroyed during flush
+                        if (this.state !== "destroyed") this.state = "ready";
                         return [
                             2 /*return*/ ,
                             {
                                 heartbeatInterval: this.heartbeatInterval,
                                 sessionId: this.sessionId,
-                                isInitiated: this.isInitiated
+                                isInitiated: true
                             }
                         ];
+                    case 6:
+                        err_1 = _a.sent();
+                        // Don't overwrite 'destroyed' state with 'failed'
+                        if (this.state !== "destroyed") this.state = "failed";
+                        this.eventQueue = [];
+                        throw err_1;
+                    case 7:
+                        return [
+                            2 /*return*/ 
+                        ];
                 }
             });
         });
     };
     $1d47cc84225ea891$export$957313a2f485e5ed.prototype.send = function(data) {
-        if (!this.isInitiated) return console.warn("[AnalyticsReporter] Cannot report before initiation:", data);
-        var payload = $1d47cc84225ea891$var$__assign({
-            sessionId: this.sessionId
-        }, data);
-        if (this.debug) console.log("[AnalyticsReporter] Send payload:", payload);
-        else fetch("".concat(this.eventsinkUrl), {
+        switch(this.state){
+            case "ready":
+                this.dispatch(data);
+                break;
+            case "initializing":
+                if (this.eventQueue.length >= $1d47cc84225ea891$var$MAX_QUEUE_SIZE) {
+                    console.warn("[AnalyticsReporter] Event queue full, dropping newest event");
+                    break;
+                }
+                this.eventQueue.push(data);
+                break;
+            case "idle":
+                console.warn("[AnalyticsReporter] Cannot report before initiation:", data);
+                break;
+            case "failed":
+                console.warn("[AnalyticsReporter] Init failed, cannot send:", data);
+                break;
+            case "destroyed":
+                break;
+        }
+    };
+    $1d47cc84225ea891$export$957313a2f485e5ed.prototype.buildPayload = function(data) {
+        return $1d47cc84225ea891$var$__assign($1d47cc84225ea891$var$__assign({
+        }, data), {
+            sessionId: this.sessionId,
+            shardId: this.shardId
+        });
+    };
+    /**
+     * Deliver an event using a transport that survives page unload (tab close
+     * or reload).
+     *
+     * Uses `navigator.sendBeacon` with a `text/plain` JSON body. A plain-text
+     * body with no `X-EPAS-*` headers is a CORS "simple request", so the browser
+     * does not issue a preflight — the preflight is what gets dropped while the
+     * page is unloading, losing the event (notably the `stopped` event). The
+     * eventsink reads the event from the JSON body (`body.event`), not from
+     * headers, so the beacon is accepted.
+     *
+     * Falls back to `fetch(..., { keepalive: true })` when `sendBeacon` is
+     * unavailable or refuses the payload. Returns true when the event was handed
+     * off to a transport.
+     */ $1d47cc84225ea891$export$957313a2f485e5ed.prototype.sendBeacon = function(data) {
+        if (this.state === "destroyed") return false;
+        var payload = this.buildPayload(data);
+        if (this.debug) {
+            console.log("[AnalyticsReporter] Send beacon payload:", payload);
+            return true;
+        }
+        var body = JSON.stringify(payload);
+        if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") try {
+            var blob = new Blob([
+                body
+            ], {
+                type: "text/plain; charset=utf-8"
+            });
+            if (navigator.sendBeacon(this.eventsinkUrl, blob)) return true;
+        } catch (_a) {
+        // Fall through to the keepalive fetch fallback below.
+        }
+        if (typeof fetch === "function") try {
+            fetch("".concat(this.eventsinkUrl), {
+                method: "POST",
+                mode: "cors",
+                cache: "no-cache",
+                keepalive: true,
+                headers: {
+                    "Content-Type": "text/plain; charset=utf-8"
+                },
+                body: body
+            }).catch(function() {
+            // Best-effort during unload — nothing actionable to do on failure.
+            });
+            return true;
+        } catch (_b) {
+            return false;
+        }
+        return false;
+    };
+    $1d47cc84225ea891$export$957313a2f485e5ed.prototype.dispatch = function(data) {
+        var _this = this;
+        var payload = this.buildPayload(data);
+        if (this.debug) {
+            console.log("[AnalyticsReporter] Send payload:", payload);
+            return Promise.resolve();
+        }
+        return fetch("".concat(this.eventsinkUrl), {
             method: "POST",
             mode: "cors",
             cache: "no-cache",
@@ -240,8 +390,73 @@ var $1d47cc84225ea891$export$957313a2f485e5ed = function() {
                 "X-EPAS-Version": $76abaee2435acae3$export$8a65ed80196068d4
             },
             body: JSON.stringify(payload)
+        }).then(function(res) {
+            if (res && !res.ok) {
+                var error = {
+                    status: res.status,
+                    statusText: res.statusText,
+                    message: "Send failed: ".concat(res.status, " ").concat(res.statusText)
+                };
+                if (_this.onError) _this.onError(error, data);
+                else console.warn("[AnalyticsReporter] ".concat(error.message));
+            }
+        }).catch(function(err) {
+            var error = {
+                message: err instanceof Error ? err.message : String(err)
+            };
+            if (_this.onError) _this.onError(error, data);
+            else console.warn("[AnalyticsReporter] Send failed:", error.message);
         });
     };
+    $1d47cc84225ea891$export$957313a2f485e5ed.prototype.flushQueue = function() {
+        return $1d47cc84225ea891$var$__awaiter(this, void 0, Promise, function() {
+            var queued, _i, queued_1, event;
+            return $1d47cc84225ea891$var$__generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        queued = this.eventQueue;
+                        this.eventQueue = [];
+                        _i = 0, queued_1 = queued;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < queued_1.length)) return [
+                            3 /*break*/ ,
+                            4
+                        ];
+                        event = queued_1[_i];
+                        // Abort if destroy() was called mid-flush
+                        if (this.state === "destroyed") return [
+                            2 /*return*/ 
+                        ];
+                        return [
+                            4 /*yield*/ ,
+                            this.dispatch(event)
+                        ];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [
+                            3 /*break*/ ,
+                            1
+                        ];
+                    case 4:
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    /**
+     * Tear down the reporter. Aborts any in-flight init, discards queued
+     * events without flushing, and prevents future send() calls from
+     * dispatching. Called by PlayerAnalytics.destroy().
+     */ $1d47cc84225ea891$export$957313a2f485e5ed.prototype.destroy = function() {
+        this.state = "destroyed";
+        this.eventQueue = [];
+    };
     return $1d47cc84225ea891$export$957313a2f485e5ed;
 }();
 
@@ -369,13 +584,14 @@ var $03bb5e0d0325c534$var$__generator = undefined && undefined.__generator || fu
     }), g;
 };
 var $03bb5e0d0325c534$export$f76c463fe9cb9f15 = function() {
-    function $03bb5e0d0325c534$export$f76c463fe9cb9f15(eventsinkUrl, debug) {
+    function $03bb5e0d0325c534$export$f76c463fe9cb9f15(eventsinkUrl, debug, onError) {
         this.debug = false;
-        this.debug = debug;
+        this.debug = debug !== null && debug !== void 0 ? debug : false;
         this.eventsinkUrl = eventsinkUrl;
+        this.onError = onError;
     }
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.initiateAnalyticsReporter = function(_a) {
-        var sessionId = _a.sessionId, _b = _a.heartbeatInterval, heartbeatInterval = _b === void 0 ? $76abaee2435acae3$export$31c453b5fe09788d : _b;
+        var sessionId = _a.sessionId, shardId = _a.shardId, _b = _a.heartbeatInterval, heartbeatInterval = _b === void 0 ? $76abaee2435acae3$export$31c453b5fe09788d : _b;
         return $03bb5e0d0325c534$var$__awaiter(this, void 0, void 0, function() {
             var _c, generatedSessionId, isInitiated;
             return $03bb5e0d0325c534$var$__generator(this, function(_d) {
@@ -385,7 +601,9 @@ var $03bb5e0d0325c534$export$f76c463fe9cb9f15 = function() {
                             sessionId: sessionId,
                             eventsinkUrl: this.eventsinkUrl,
                             debug: this.debug,
-                            heartbeatInterval: heartbeatInterval
+                            heartbeatInterval: heartbeatInterval,
+                            shardId: shardId,
+                            onError: this.onError
                         });
                         return [
                             4 /*yield*/ ,
@@ -405,52 +623,87 @@ var $03bb5e0d0325c534$export$f76c463fe9cb9f15 = function() {
             });
         });
     };
+    $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.ensureReporter = function() {
+        if (!this.analyticsReporter) {
+            console.warn("[PlayerAnalytics] Not initialized. Call initiateAnalyticsReporter() first.");
+            return false;
+        }
+        return true;
+    };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.init = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.metadata = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.heartbeat = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.loading = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.loaded = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.playing = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.pause = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.buffering = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.buffered = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.seeking = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.seeked = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.bitrateChanged = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.error = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.warning = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.stopped = function(data) {
+        if (!this.ensureReporter()) return;
         this.analyticsReporter.send(data);
     };
+    /**
+     * Send a stopped event over the reporter's unload-safe beacon transport
+     * (navigator.sendBeacon with a fetch keepalive fallback). Used to deliver the
+     * stopped event when the page is closed or reloaded mid-playback, where a
+     * normal CORS fetch would be dropped during unload. Returns true when the
+     * event was handed off to a transport.
+     */ $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.stoppedViaBeacon = function(data) {
+        if (!this.ensureReporter()) return false;
+        return this.analyticsReporter.sendBeacon(data);
+    };
     $03bb5e0d0325c534$export$f76c463fe9cb9f15.prototype.destroy = function() {
+        // Cascade destroy to the reporter so any in-flight init is aborted
+        // and queued events are discarded rather than flushed.
+        if (this.analyticsReporter) this.analyticsReporter.destroy();
         this.analyticsReporter = null;
     };
     return $03bb5e0d0325c534$export$f76c463fe9cb9f15;
@@ -595,32 +848,83 @@ var $85819f9bdebfd936$var$__generator = undefined && undefined.__generator || fu
     }), g;
 };
 var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
-    function $85819f9bdebfd936$export$2daf9923c014a26e(eventsinkUrl, debug) {
+    function $85819f9bdebfd936$export$2daf9923c014a26e(eventsinkUrl, debug, onError) {
+        var _this = this;
         this.analyticsInitiated = false;
+        this.initCalled = false;
+        this.initGeneration = 0;
+        // Direct DOM fallback for terminal/seek events on an element that was already
+        // playing when load() ran (autoplay started during a slow init() handshake).
+        // The media-event-filter attaches in its "loading" state and, never having
+        // observed the initial playing/canplaythrough transitions, stays stuck there
+        // and suppresses ENDED/SEEKING/SEEKED. These listeners drive that path
+        // directly. They self-disable the moment the filter proves it is live (emits
+        // any event), so a seek is never reported twice across the two sources.
+        this.autoplayFallbackActive = false;
+        this.pendingHeartbeatStart = false;
+        // Tracks whether a stopped event has already been reported for the current
+        // session, so the page-unload path does not emit a duplicate after an
+        // `ended`, reportStop(), or reportError() has already stopped the session.
+        this.stoppedReported = false;
+        this.unloadListenersRegistered = false;
+        this.handleAutoplayEnded = function() {
+            // Mirror the filter's ENDED branch: exactly one stopped(ended), stop
+            // heartbeats, and respect the stoppedReported guard so reportStop/
+            // reportError/unload can't produce a duplicate.
+            if (_this.stoppedReported) return;
+            _this.stoppedReported = true;
+            _this.stopInterval();
+            _this.sendFilteredEvent("stopped", {
+                reason: "ended"
+            });
+        };
+        this.handleAutoplaySeeking = function() {
+            _this.sendFilteredEvent("seeking");
+        };
+        this.handleAutoplaySeeked = function() {
+            _this.sendFilteredEvent("seeked");
+        };
+        this.handlePageHide = function() {
+            _this.flushStoppedOnUnload();
+        };
         this.eventsinkUrl = eventsinkUrl;
-        this.playerAnalytics = new $03bb5e0d0325c534$exports.PlayerAnalytics(this.eventsinkUrl, debug);
+        this.playerAnalytics = new $03bb5e0d0325c534$exports.PlayerAnalytics(this.eventsinkUrl, debug, onError);
     }
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.init = function(options) {
         return $85819f9bdebfd936$var$__awaiter(this, void 0, void 0, function() {
-            var _a, heartbeatInterval, isInitiated;
-            return $85819f9bdebfd936$var$__generator(this, function(_b) {
-                switch(_b.label){
-                    case 0:
-                        this.sessionId = options.sessionId;
-                        return [
-                            4 /*yield*/ ,
-                            this.playerAnalytics.initiateAnalyticsReporter($85819f9bdebfd936$var$__assign({
-                                sessionId: this.sessionId
-                            }, options))
-                        ];
-                    case 1:
-                        _a = _b.sent(), heartbeatInterval = _a.heartbeatInterval, isInitiated = _a.isInitiated;
-                        this.analyticsInitiated = isInitiated;
-                        this.heartbeatInterval = heartbeatInterval;
-                        return [
-                            2 /*return*/ 
-                        ];
-                }
+            var currentGeneration, initPromise;
+            var _this = this;
+            return $85819f9bdebfd936$var$__generator(this, function(_a) {
+                this.sessionId = options.sessionId;
+                this.initCalled = true;
+                this.stoppedReported = false;
+                currentGeneration = ++this.initGeneration;
+                initPromise = this.playerAnalytics.initiateAnalyticsReporter($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
+                }, options), {
+                    sessionId: this.sessionId
+                }));
+                initPromise.then(function(result) {
+                    // Ignore stale init completions (e.g., if destroy() was called during init)
+                    if (currentGeneration !== _this.initGeneration) return;
+                    _this.analyticsInitiated = result.isInitiated === true;
+                    _this.heartbeatInterval = Number(result.heartbeatInterval) || _this.heartbeatInterval;
+                    if (typeof result.sessionId === "string" && result.sessionId) _this.sessionId = result.sessionId;
+                    if (_this.pendingHeartbeatStart) {
+                        _this.pendingHeartbeatStart = false;
+                        _this.startInterval();
+                    }
+                }).catch(function(err) {
+                    if (currentGeneration !== _this.initGeneration) return;
+                    // Reset pendingHeartbeatStart so a retry doesn't fire heartbeats
+                    // from a stale flag without a new PLAYING event.
+                    _this.pendingHeartbeatStart = false;
+                    var message = err instanceof Error ? err.message : String(err);
+                    console.warn("[PlayerAnalyticsConnector] Init failed:", message);
+                });
+                return [
+                    2 /*return*/ ,
+                    initPromise
+                ];
             });
         });
     };
@@ -630,6 +934,30 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
             event: "loading"
         }, this.playbackState()));
         this.initiateVideoEventFilter();
+        this.registerUnloadListeners();
+        // If the element is already playing by the time load() is called (e.g.
+        // autoplay started during a slow init() handshake, before listeners were
+        // attached), the media-event-filter won't emit a fresh PLAYING for the
+        // DOM "playing" event that already fired. Emit it ourselves and start the
+        // heartbeat so the session isn't lost. While init() is still in-flight the
+        // event is queued by the Reporter and the heartbeat start is deferred via
+        // pendingHeartbeatStart, flushing once the handshake completes.
+        if (this.isPlayerAlreadyPlaying()) {
+            this.playerAnalytics.playing($85819f9bdebfd936$var$__assign({
+                event: "playing"
+            }, this.playbackState()));
+            this.startInterval();
+            // The filter won't emit terminal/seek events for this already-playing
+            // element (see isPlayerAlreadyPlaying / initiateVideoEventFilter notes),
+            // so drive ended/seeking/seeked from the element's own DOM events.
+            this.attachAutoplayTerminalFallback();
+        }
+    };
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.isPlayerAlreadyPlaying = function() {
+        // HAVE_FUTURE_DATA (readyState 3) mirrors the media-event-filter's own
+        // "ready" threshold. Use the numeric literal rather than
+        // HTMLMediaElement.HAVE_FUTURE_DATA so this works in non-DOM test envs.
+        return !!(this.player && !this.player.paused && !this.player.ended && this.player.readyState >= 3);
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.initiateVideoEventFilter = function() {
         var _this = this;
@@ -638,6 +966,11 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
             mediaElement: this.player,
             mp4Mode: false,
             callback: function(event) {
+                // The filter emitting anything means it has left its initial "loading"
+                // state and is now the authoritative source for terminal/seek events;
+                // retire the autoplay DOM fallback so a single seek/ended is not
+                // reported twice.
+                _this.detachAutoplayTerminalFallback();
                 var eventType;
                 var extraData = {
                 };
@@ -665,32 +998,65 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
                         eventType = "buffered";
                         break;
                     case $hCgyA$FilteredMediaEvent.ENDED:
+                        // Guard against a duplicate stopped(ended) if the autoplay fallback
+                        // (or reportStop/reportError) already ended the session.
+                        if (_this.stoppedReported) return;
                         eventType = "stopped";
                         extraData["reason"] = "ended";
+                        _this.stoppedReported = true;
                         _this.stopInterval();
                         break;
                     default:
                         break;
                 }
-                try {
-                    if (!_this.analyticsInitiated) {
-                        console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
-                        return;
-                    }
-                    if (eventType) _this.playerAnalytics[eventType == "paused" ? "pause" : eventType]($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
-                        event: eventType
-                    }, _this.playbackState()), Object.keys(extraData).length > 0 && {
-                        payload: extraData
-                    }));
-                } catch (err) {
-                    console.error(err);
-                }
+                _this.sendFilteredEvent(eventType, extraData);
             }
         });
     };
+    // Shared emit path for events sourced from the media-event-filter and from
+    // the autoplay DOM fallback, so both behave identically (init guard, the
+    // paused→pause method-name mapping, optional payload, error swallowing).
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.sendFilteredEvent = function(eventType, extraData) {
+        if (extraData === void 0) extraData = {
+        };
+        try {
+            if (!this.initCalled) {
+                console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
+                return;
+            }
+            if (eventType) this.playerAnalytics[eventType == "paused" ? "pause" : eventType]($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
+                event: eventType
+            }, this.playbackState()), Object.keys(extraData).length > 0 && {
+                payload: extraData
+            }));
+        } catch (err) {
+            console.error(err);
+        }
+    };
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.attachAutoplayTerminalFallback = function() {
+        if (this.autoplayFallbackActive) return;
+        if (!this.player || typeof this.player.addEventListener !== "function") return;
+        this.autoplayFallbackActive = true;
+        this.player.addEventListener("ended", this.handleAutoplayEnded);
+        this.player.addEventListener("seeking", this.handleAutoplaySeeking);
+        this.player.addEventListener("seeked", this.handleAutoplaySeeked);
+    };
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.detachAutoplayTerminalFallback = function() {
+        if (!this.autoplayFallbackActive) return;
+        this.autoplayFallbackActive = false;
+        if (this.player && typeof this.player.removeEventListener === "function") {
+            this.player.removeEventListener("ended", this.handleAutoplayEnded);
+            this.player.removeEventListener("seeking", this.handleAutoplaySeeking);
+            this.player.removeEventListener("seeked", this.handleAutoplaySeeked);
+        }
+    };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.startInterval = function() {
         var _this = this;
         if (this.heartbeatIntervalTimer) return;
+        if (!this.heartbeatInterval) {
+            this.pendingHeartbeatStart = true;
+            return;
+        }
         this.heartbeatIntervalTimer = setInterval(function() {
             _this.playerAnalytics.heartbeat($85819f9bdebfd936$var$__assign({
                 event: "heartbeat"
@@ -699,9 +1065,11 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.stopInterval = function() {
         clearInterval(this.heartbeatIntervalTimer);
+        this.heartbeatIntervalTimer = null;
+        this.pendingHeartbeatStart = false;
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.reportBitrateChange = function(payload) {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
@@ -712,21 +1080,32 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
         }));
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.reportStop = function() {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
-        this.playerAnalytics.stopped($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
+        // Already stopped this session (an `ended`, reportError(), or a prior
+        // unload beacon) — don't emit a duplicate stopped.
+        if (this.stoppedReported) return;
+        this.stoppedReported = true;
+        this.stopInterval();
+        // Deliver over the unload-safe beacon transport (sendBeacon / keepalive
+        // fetch), not the normal CORS fetch. Integrators call reportStop() from
+        // pagehide/unload handlers, where the browser drops the preflighted CORS
+        // fetch and the event is lost. Routing through the same beacon the SDK's
+        // own unload path uses means setting `stoppedReported` here lets
+        // flushStoppedOnUnload() short-circuit without losing the event, so
+        // exactly one stopped is delivered.
+        this.playerAnalytics.stoppedViaBeacon($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
             event: "stopped"
         }, this.playbackState()), {
             payload: {
                 reason: "aborted"
             }
         }));
-        this.stopInterval();
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.reportError = function(error) {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
@@ -742,10 +1121,11 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
                 reason: "error"
             }
         }));
+        this.stoppedReported = true;
         this.stopInterval();
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.reportMetadata = function(payload) {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
@@ -756,7 +1136,7 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
         }));
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.reportWarning = function(payload) {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
@@ -769,7 +1149,7 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.playbackState = function() {
         var _a, _b, _c, _d, _e;
         var duration = ((_a = this.player) === null || _a === void 0 ? void 0 : _a.duration) && ((_b = this.player) === null || _b === void 0 ? void 0 : _b.duration) !== Infinity && ((_c = this.player) === null || _c === void 0 ? void 0 : _c.duration) > 0 ? this.player.duration : -1;
-        var playhead = ((_d = this.player) === null || _d === void 0 ? void 0 : _d.currentTime) && duration !== -1 ? (_e = this.player) === null || _e === void 0 ? void 0 : _e.currentTime : -1;
+        var playhead = ((_d = this.player) === null || _d === void 0 ? void 0 : _d.currentTime) != null && this.player.currentTime >= 0 ? (_e = this.player) === null || _e === void 0 ? void 0 : _e.currentTime : -1;
         return {
             sessionId: this.sessionId,
             timestamp: Date.now(),
@@ -777,25 +1157,73 @@ var $85819f9bdebfd936$export$2daf9923c014a26e = function() {
             duration: duration
         };
     };
+    /**
+     * Deliver a stopped event when the page is being unloaded (tab closed or
+     * reloaded) mid-session. Driven by `pagehide`, which fires on genuine
+     * discard (close/reload/navigate-away) but NOT on an ordinary tab switch —
+     * the browser drops the normal CORS fetch (it needs a preflight) during
+     * unload, losing the event, so the stopped event goes out over the
+     * reporter's beacon transport instead. It is sent only once per session (a
+     * later `ended`, reportStop(), or reportError() will already have reported
+     * stopped). `visibilitychange→hidden` is deliberately NOT used here: a tab
+     * switch / backgrounding is not an unload and must not end a still-playing
+     * session (see #44).
+     */ $85819f9bdebfd936$export$2daf9923c014a26e.prototype.flushStoppedOnUnload = function() {
+        if (!this.initCalled || this.stoppedReported || !this.player) return;
+        this.stoppedReported = true;
+        this.stopInterval();
+        this.playerAnalytics.stoppedViaBeacon($85819f9bdebfd936$var$__assign($85819f9bdebfd936$var$__assign({
+            event: "stopped"
+        }, this.playbackState()), {
+            payload: {
+                reason: "aborted"
+            }
+        }));
+    };
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.registerUnloadListeners = function() {
+        if (this.unloadListenersRegistered) return;
+        if (typeof window !== "undefined" && typeof window.addEventListener === "function") window.addEventListener("pagehide", this.handlePageHide);
+        this.unloadListenersRegistered = true;
+    };
+    $85819f9bdebfd936$export$2daf9923c014a26e.prototype.removeUnloadListeners = function() {
+        if (!this.unloadListenersRegistered) return;
+        if (typeof window !== "undefined" && typeof window.removeEventListener === "function") window.removeEventListener("pagehide", this.handlePageHide);
+        this.unloadListenersRegistered = false;
+    };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.deinit = function() {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
+        this.initGeneration++; // Invalidate any pending init callbacks
+        // Abort any in-flight init so queued events don't flush after teardown.
+        // The next init() call creates a fresh Reporter, so destroying the
+        // current one is safe even though deinit is meant to be reusable.
+        this.playerAnalytics.destroy();
         this.stopInterval();
+        this.removeUnloadListeners();
+        this.detachAutoplayTerminalFallback();
         this.heartbeatInterval = null;
         this.videoEventFilter && this.videoEventFilter.teardown();
         this.videoEventFilter = null;
+        this.analyticsInitiated = false;
+        this.initCalled = false;
     };
     $85819f9bdebfd936$export$2daf9923c014a26e.prototype.destroy = function() {
-        if (!this.analyticsInitiated) {
+        if (!this.initCalled) {
             console.warn("[PlayerAnalyticsConnector] Analytics not initiated");
             return;
         }
+        this.initGeneration++; // Invalidate any pending init callbacks
+        this.stopInterval();
         this.playerAnalytics.destroy();
+        this.removeUnloadListeners();
+        this.detachAutoplayTerminalFallback();
         this.heartbeatInterval = null;
         this.videoEventFilter && this.videoEventFilter.teardown();
-        this.stopInterval();
+        this.videoEventFilter = null;
+        this.analyticsInitiated = false;
+        this.initCalled = false;
     };
     return $85819f9bdebfd936$export$2daf9923c014a26e;
 }();