@mebius-io/web 0.5.4 → 0.6.1

package/dist/index.d.cts

@@ -149,6 +149,13 @@ interface CaptionSegment {
     durationMs: number;
     /** Original transcript, in the source language. */
     text: string;
+    /**
+     * Language `text` is actually in, as the recogniser identified it. With an
+     * "auto" source this varies per sentence, so a client showing `text` as a
+     * subtitle must check this rather than assume it matches what the viewer
+     * asked for.
+     */
+    srcLang?: string;
     /** The requested {@link CaptionsOptions.lang} translation, if produced yet. */
     translation?: string;
     /** Always `true`. Render a machine-generated indicator — never as a direct quote. */
@@ -417,13 +424,37 @@ declare class MebiusCaptions extends TypedEmitter<CaptionsEventMap> {
     private es;
     private timer;
     private readonly pending;
+    /**
+     * segmentId -> the rev already handed to listeners. Not a Set: with interim
+     * revisions on, a segment stays pending while it is being corrected, and a
+     * plain "have I shown this id" check re-emits the same unchanged text on
+     * every 100ms tick. Comparing revs emits exactly once per actual revision.
+     */
     private readonly shown;
+    /** Kept so the feed can be reopened after a hidden-tab suspend. */
+    private streamId;
+    private hiddenTimer;
+    private onVisibility;
     /** @internal */
     constructor(signaling: SignalingClient, player: MebiusPlayer, opts: CaptionsOptions);
     /** Open the SSE connection and begin emitting segments for `streamId`. */
     start(streamId: string): void;
     /** Close the connection and drop all buffered segments. */
     stop(): void;
+    private openFeed;
+    private closeFeed;
+    /**
+     * Drop the feed while the page is hidden, restore it when it comes back.
+     *
+     * Nothing here is about rendering — a hidden tab shows no captions either
+     * way. It is about not holding a subscriber open, since that subscriber is
+     * what keeps a billed session alive on the engine.
+     *
+     * Buffered segments are deliberately kept across a suspend: they age out on
+     * their own (STALE_MS) and clearing them would blank the screen on return
+     * for no benefit.
+     */
+    private watchVisibility;
     private onFrame;
     private tick;
 }

package/dist/index.d.ts

@@ -149,6 +149,13 @@ interface CaptionSegment {
     durationMs: number;
     /** Original transcript, in the source language. */
     text: string;
+    /**
+     * Language `text` is actually in, as the recogniser identified it. With an
+     * "auto" source this varies per sentence, so a client showing `text` as a
+     * subtitle must check this rather than assume it matches what the viewer
+     * asked for.
+     */
+    srcLang?: string;
     /** The requested {@link CaptionsOptions.lang} translation, if produced yet. */
     translation?: string;
     /** Always `true`. Render a machine-generated indicator — never as a direct quote. */
@@ -417,13 +424,37 @@ declare class MebiusCaptions extends TypedEmitter<CaptionsEventMap> {
     private es;
     private timer;
     private readonly pending;
+    /**
+     * segmentId -> the rev already handed to listeners. Not a Set: with interim
+     * revisions on, a segment stays pending while it is being corrected, and a
+     * plain "have I shown this id" check re-emits the same unchanged text on
+     * every 100ms tick. Comparing revs emits exactly once per actual revision.
+     */
     private readonly shown;
+    /** Kept so the feed can be reopened after a hidden-tab suspend. */
+    private streamId;
+    private hiddenTimer;
+    private onVisibility;
     /** @internal */
     constructor(signaling: SignalingClient, player: MebiusPlayer, opts: CaptionsOptions);
     /** Open the SSE connection and begin emitting segments for `streamId`. */
     start(streamId: string): void;
     /** Close the connection and drop all buffered segments. */
     stop(): void;
+    private openFeed;
+    private closeFeed;
+    /**
+     * Drop the feed while the page is hidden, restore it when it comes back.
+     *
+     * Nothing here is about rendering — a hidden tab shows no captions either
+     * way. It is about not holding a subscriber open, since that subscriber is
+     * what keeps a billed session alive on the engine.
+     *
+     * Buffered segments are deliberately kept across a suspend: they age out on
+     * their own (STALE_MS) and clearing them would blank the screen on return
+     * for no benefit.
+     */
+    private watchVisibility;
     private onFrame;
     private tick;
 }

package/dist/index.global.js

@@ -43428,6 +43428,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
   var TICK_MS = 100;
   var STALE_MS = 5e3;
   var MAX_QUEUE_MS = 1500;
+  var HIDDEN_GRACE_MS = 6e4;
   var MebiusCaptions = class extends TypedEmitter {
     /** @internal */
     constructor(signaling, player, opts) {
@@ -43438,26 +43439,81 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
       this.es = null;
       this.timer = null;
       this.pending = /* @__PURE__ */ new Map();
-      this.shown = /* @__PURE__ */ new Set();
+      /**
+       * segmentId -> the rev already handed to listeners. Not a Set: with interim
+       * revisions on, a segment stays pending while it is being corrected, and a
+       * plain "have I shown this id" check re-emits the same unchanged text on
+       * every 100ms tick. Comparing revs emits exactly once per actual revision.
+       */
+      this.shown = /* @__PURE__ */ new Map();
+      /** Kept so the feed can be reopened after a hidden-tab suspend. */
+      this.streamId = null;
+      this.hiddenTimer = null;
+      this.onVisibility = null;
     }
     /** Open the SSE connection and begin emitting segments for `streamId`. */
     start(streamId) {
       if (this.es) return;
-      const url = this.signaling.captionsUrl(streamId, this.opts.lang);
-      const es = new EventSource(url);
+      this.streamId = streamId;
+      this.openFeed();
+      this.watchVisibility();
+    }
+    /** Close the connection and drop all buffered segments. */
+    stop() {
+      this.streamId = null;
+      if (this.onVisibility && typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", this.onVisibility);
+      }
+      this.onVisibility = null;
+      if (this.hiddenTimer) clearTimeout(this.hiddenTimer);
+      this.hiddenTimer = null;
+      this.closeFeed();
+      this.pending.clear();
+      this.shown.clear();
+    }
+    openFeed() {
+      if (this.es || !this.streamId) return;
+      const es = new EventSource(this.signaling.captionsUrl(this.streamId, this.opts.lang));
       es.onmessage = (ev) => this.onFrame(ev);
       es.onerror = () => this.emit("error", void 0);
       this.es = es;
       this.timer = setInterval(() => this.tick(), TICK_MS);
     }
-    /** Close the connection and drop all buffered segments. */
-    stop() {
+    closeFeed() {
       this.es?.close();
       this.es = null;
       if (this.timer) clearInterval(this.timer);
       this.timer = null;
-      this.pending.clear();
-      this.shown.clear();
+    }
+    /**
+     * Drop the feed while the page is hidden, restore it when it comes back.
+     *
+     * Nothing here is about rendering — a hidden tab shows no captions either
+     * way. It is about not holding a subscriber open, since that subscriber is
+     * what keeps a billed session alive on the engine.
+     *
+     * Buffered segments are deliberately kept across a suspend: they age out on
+     * their own (STALE_MS) and clearing them would blank the screen on return
+     * for no benefit.
+     */
+    watchVisibility() {
+      if (typeof document === "undefined") return;
+      this.onVisibility = () => {
+        if (document.visibilityState === "hidden") {
+          if (this.hiddenTimer) return;
+          this.hiddenTimer = setTimeout(() => {
+            this.hiddenTimer = null;
+            this.closeFeed();
+          }, HIDDEN_GRACE_MS);
+          return;
+        }
+        if (this.hiddenTimer) {
+          clearTimeout(this.hiddenTimer);
+          this.hiddenTimer = null;
+        }
+        this.openFeed();
+      };
+      document.addEventListener("visibilitychange", this.onVisibility);
     }
     onFrame(ev) {
       let frame;
@@ -43487,8 +43543,9 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
           this.emit("cleared", { segmentId: id });
           continue;
         }
-        if (this.shown.has(id) && frame.state === "final") continue;
-        this.shown.add(id);
+        const rev = frame.rev ?? 0;
+        if (this.shown.get(id) === rev) continue;
+        this.shown.set(id, rev);
         this.emit("segment", toSegment(id, frame, this.opts.lang));
       }
     }
@@ -43501,6 +43558,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
       epochMs: frame.epochMs ?? 0,
       durationMs: frame.durationMs ?? 0,
       text: frame.text ?? "",
+      srcLang: frame.srcLang,
       translation: frame.translations?.[lang],
       machineGenerated: true
     };