@mebius-io/web 0.4.2 → 0.4.4

package/dist/index.d.ts

@@ -273,13 +273,30 @@ declare class MebiusPlayer extends TypedEmitter<PlayerEventMap> {
     private statsTimer;
     private playing;
     private reporter;
+    /** True between a `buffering` event and the element actually resuming. */
+    private stalled;
+    /** Cancels element listeners bound for the lifetime of one play(). */
+    private elementListeners;
     /** @internal */
     constructor(signaling: SignalingClient, options?: PlayerOptions, deliveries?: readonly MebiusDelivery[], telemetry?: TelemetryTarget | null, userId?: string | undefined);
     /** Start playing `streamId` into the given video element or selector. */
     play(streamId: string, viewTarget: ViewTarget): Promise<void>;
     /** Stop playback and detach from the video element. */
     stop(): Promise<void>;
-    /** Set output volume in the range 0..1. */
+    /**
+     * Set output volume in the range 0..1.
+     *
+     * Any volume above zero also unmutes. Playback often starts muted — the
+     * element may carry `muted` in the app's own markup, and the SDK itself mutes
+     * and retries when the browser refuses to autoplay with sound — and
+     * `video.volume` has no audible effect while `muted` is set. Setting volume
+     * without clearing it meant an app whose only audio control was a slider
+     * could never produce sound: the value moved, the stream stayed silent, and
+     * nothing reported a problem.
+     *
+     * Volume 0 mutes rather than merely turning the level down, so a UI that
+     * drags to zero also survives a later unmute at the element level.
+     */
     setVolume(volume: number): void;
     private attach;
     private startStats;

package/dist/index.global.js

@@ -43113,7 +43113,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
   }
 
   // src/internal/telemetry.ts
-  var SDK_VERSION = "web/0.4.2";
+  var SDK_VERSION = "web/0.4.4";
   var FLUSH_INTERVAL_MS = 15e3;
   var MAX_BATCH = 64;
   function describeDevice() {
@@ -43307,6 +43307,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
   // src/player.ts
   var STATS_INTERVAL_MS2 = 2e3;
   var FIRST_FRAME_TIMEOUT_MS = 8e3;
+  var ELEMENT_OWNER = /* @__PURE__ */ new WeakMap();
   var MebiusPlayer = class extends TypedEmitter {
     /** @internal */
     constructor(signaling, options = {}, deliveries = [], telemetry = null, userId) {
@@ -43318,13 +43319,30 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
       this.statsTimer = null;
       this.playing = false;
       this.reporter = null;
+      /** True between a `buffering` event and the element actually resuming. */
+      this.stalled = false;
+      /** Cancels element listeners bound for the lifetime of one play(). */
+      this.elementListeners = null;
       this.candidates = createViewCandidates(options.mode ?? "auto", signaling, deliveries);
     }
     /** Start playing `streamId` into the given video element or selector. */
     async play(streamId, viewTarget) {
       if (this.playing) return;
       const video = resolveVideoElement(viewTarget);
+      const previous = ELEMENT_OWNER.get(video);
+      if (previous && previous !== this) await previous.stop();
+      ELEMENT_OWNER.set(video, this);
       this.video = video;
+      this.elementListeners = new AbortController();
+      video.addEventListener(
+        "playing",
+        () => {
+          if (!this.stalled || !this.playing) return;
+          this.stalled = false;
+          this.emit("playing", { streamId });
+        },
+        { signal: this.elementListeners.signal }
+      );
       const startedAtMs = Date.now();
       let lastError = null;
       for (const candidate of this.candidates) {
@@ -43355,6 +43373,12 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
     }
     /** Stop playback and detach from the video element. */
     async stop() {
+      this.elementListeners?.abort();
+      this.elementListeners = null;
+      if (this.video && ELEMENT_OWNER.get(this.video) === this) {
+        ELEMENT_OWNER.delete(this.video);
+      }
+      this.stalled = false;
       this.stopStats();
       await this.reporter?.stop();
       this.reporter = null;
@@ -43363,10 +43387,25 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
       this.video = null;
       this.playing = false;
     }
-    /** Set output volume in the range 0..1. */
+    /**
+     * Set output volume in the range 0..1.
+     *
+     * Any volume above zero also unmutes. Playback often starts muted — the
+     * element may carry `muted` in the app's own markup, and the SDK itself mutes
+     * and retries when the browser refuses to autoplay with sound — and
+     * `video.volume` has no audible effect while `muted` is set. Setting volume
+     * without clearing it meant an app whose only audio control was a slider
+     * could never produce sound: the value moved, the stream stayed silent, and
+     * nothing reported a problem.
+     *
+     * Volume 0 mutes rather than merely turning the level down, so a UI that
+     * drags to zero also survives a later unmute at the element level.
+     */
     setVolume(volume) {
       const v = Math.min(1, Math.max(0, volume));
-      if (this.video) this.video.volume = v;
+      if (!this.video) return;
+      this.video.volume = v;
+      this.video.muted = v === 0;
     }
     attach(transport) {
       transport.onEnded(() => {
@@ -43379,6 +43418,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
       });
       transport.onBuffering(() => {
         if (this.transport !== transport) return;
+        this.stalled = true;
         this.emit("buffering", void 0);
       });
     }