@livepeer-frameworks/player-core 0.0.3 → 0.1.0

package/src/core/PlayerController.ts

@@ -9,12 +9,12 @@
  */
 
 import { TypedEventEmitter } from './EventEmitter';
-import { GatewayClient, GatewayStatus } from './GatewayClient';
+import { GatewayClient } from './GatewayClient';
 import { StreamStateClient } from './StreamStateClient';
 import { PlayerManager } from './PlayerManager';
 import { globalPlayerManager, ensurePlayersRegistered } from './PlayerRegistry';
 import { ABRController } from './ABRController';
-import { InteractionController, type InteractionControllerConfig } from './InteractionController';
+import { InteractionController } from './InteractionController';
 import { MistReporter } from './MistReporter';
 import { QualityMonitor } from './QualityMonitor';
 import { MetaTrackManager } from './MetaTrackManager';
@@ -25,7 +25,6 @@ import {
   canSeekStream,
   isMediaStreamSource,
   supportsPlaybackRate,
-  isLiveContent,
   getLatencyTier,
   type LatencyTier,
   type LiveThresholds,
@@ -35,6 +34,7 @@ import type {
   ContentEndpoints,
   ContentMetadata,
   EndpointInfo,
+  MistStreamInfo,
   OutputEndpoint,
   OutputCapabilities,
   PlayerState,
@@ -51,7 +51,7 @@ export interface PlayerControllerConfig {
   /** Content identifier (stream name) */
   contentId: string;
   /** Content type */
-  contentType: ContentType;
+  contentType?: ContentType;
 
   /** Pre-resolved endpoints (skip gateway) */
   endpoints?: ContentEndpoints;
@@ -182,6 +182,10 @@ export interface PlayerControllerEvents {
   };
 }
 
+// ============================================================================
+// Content Type Resolution Helpers
+// ============================================================================
+
 // ============================================================================
 // MistServer Source Type Mapping
 // ============================================================================
@@ -206,6 +210,8 @@ export const MIST_SOURCE_TYPES: Record<string, { hrn: string; player: string; su
   // ===== WEBSOCKET STREAMING =====
   'ws/video/mp4': { hrn: 'MP4 WebSocket', player: 'mews', supported: true },
   'wss/video/mp4': { hrn: 'MP4 WebSocket (SSL)', player: 'mews', supported: true },
+  'ws/video/webm': { hrn: 'WebM WebSocket', player: 'mews', supported: true },
+  'wss/video/webm': { hrn: 'WebM WebSocket (SSL)', player: 'mews', supported: true },
   'ws/video/raw': { hrn: 'Raw WebSocket', player: 'webcodecs', supported: true },
   'wss/video/raw': { hrn: 'Raw WebSocket (SSL)', player: 'webcodecs', supported: true },
   'ws/video/h264': { hrn: 'Annex B WebSocket', player: 'webcodecs', supported: true },
@@ -214,6 +220,7 @@ export const MIST_SOURCE_TYPES: Record<string, { hrn: string; player: string; su
   // ===== WEBRTC =====
   'whep': { hrn: 'WebRTC (WHEP)', player: 'native', supported: true },
   'webrtc': { hrn: 'WebRTC (WebSocket)', player: 'mist-webrtc', supported: true },
+  'mist/webrtc': { hrn: 'MistServer WebRTC', player: 'mist-webrtc', supported: true },
 
   // ===== AUDIO ONLY =====
   'html5/audio/aac': { hrn: 'AAC progressive', player: 'native', supported: true },
@@ -259,13 +266,18 @@ export const PROTOCOL_TO_MIME: Record<string, string> = {
   'WEBM': 'html5/video/webm',
   'WHEP': 'whep',
   'WebRTC': 'webrtc',
+  'MIST_WEBRTC': 'mist/webrtc',  // MistServer native WebRTC signaling
 
   // WebSocket variants
   'MEWS': 'ws/video/mp4',
   'MEWS_WS': 'ws/video/mp4',
   'MEWS_WSS': 'wss/video/mp4',
+  'MEWS_WEBM': 'ws/video/webm',
+  'MEWS_WEBM_SSL': 'wss/video/webm',
   'RAW_WS': 'ws/video/raw',
   'RAW_WSS': 'wss/video/raw',
+  'H264_WS': 'ws/video/h264',
+  'H264_WSS': 'wss/video/h264',
 
   // Audio
   'AAC': 'html5/audio/aac',
@@ -355,7 +367,7 @@ export function buildStreamInfoFromEndpoints(
     if (typeof primary.outputs === 'string') {
       try {
         outputs = JSON.parse(primary.outputs);
-      } catch (e) {
+      } catch {
         console.warn('[buildStreamInfoFromEndpoints] Failed to parse outputs JSON');
         outputs = {};
       }
@@ -367,7 +379,6 @@ export function buildStreamInfoFromEndpoints(
   const sources: StreamSource[] = [];
   const oKeys = Object.keys(outputs);
 
-  // Helper to attach MistServer sources
   const attachMistSource = (html?: string, playerJs?: string) => {
     if (!html && !playerJs) return;
     const src: StreamSource = {
@@ -473,7 +484,7 @@ export function buildStreamInfoFromEndpoints(
  * @example
  * ```typescript
  * const controller = new PlayerController({
- *   contentId: 'my-stream',
+ *   contentId: 'pk_...', // playbackId (view key)
  *   contentType: 'live',
  *   gatewayUrl: 'https://gateway.example.com/graphql',
  * });
@@ -493,7 +504,6 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
   private state: PlayerState = 'booting';
   private lastEmittedState: PlayerState | null = null;
   private suppressPlayPauseEventsUntil = 0;
-  private suppressPlayPauseEventsUntil = 0;
 
   private gatewayClient: GatewayClient | null = null;
   private streamStateClient: StreamStateClient | null = null;
@@ -508,6 +518,10 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
   private streamState: StreamState | null = null;
   /** Tracks parsed from MistServer JSON response (used for direct MistServer mode) */
   private mistTracks: StreamTrack[] | null = null;
+  /** Gateway-seeded metadata (used as base for Mist enrichment) */
+  private metadataSeed: ContentMetadata | null = null;
+  /** Merged metadata (gateway seed + Mist enrichment) */
+  private metadata: ContentMetadata | null = null;
 
   private cleanupFns: Array<() => void> = [];
   private isDestroyed: boolean = false;
@@ -698,6 +712,8 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
     this.endpoints = null;
     this.streamInfo = null;
     this.streamState = null;
+    this.metadataSeed = null;
+    this.metadata = null;
     this.videoElement = null;
     this.currentPlayer = null;
     this.lastEmittedState = null;
@@ -738,7 +754,130 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
   /** Get content metadata (title, description, duration, etc.) */
   getMetadata(): ContentMetadata | null {
-    return this.endpoints?.metadata ?? null;
+    return this.metadata ?? null;
+  }
+
+  // ============================================================================
+  // Metadata Merge (Gateway seed + Mist enrichment)
+  // ============================================================================
+
+  private setMetadataSeed(seed: ContentMetadata | null | undefined): void {
+    this.metadataSeed = seed ? { ...seed } : null;
+    this.refreshMergedMetadata();
+  }
+
+  private refreshMergedMetadata(): void {
+    const seed = this.metadataSeed ? { ...this.metadataSeed } : null;
+    const mist = this.streamState?.streamInfo;
+    const streamStatus = this.streamState?.status;
+
+    if (!seed && !mist) {
+      this.metadata = null;
+      return;
+    }
+
+    const merged: ContentMetadata = seed ? { ...seed } : {};
+
+    if (mist) {
+      merged.mist = this.sanitizeMistInfo(mist);
+      if (mist.type) {
+        merged.contentType = mist.type;
+        merged.isLive = mist.type === 'live';
+      }
+      if (streamStatus) {
+        merged.status = streamStatus;
+      }
+      if (mist.meta?.duration && (!merged.durationSeconds || merged.durationSeconds <= 0)) {
+        merged.durationSeconds = Math.round(mist.meta.duration);
+      }
+      if (mist.meta?.tracks) {
+        merged.tracks = this.buildMetadataTracks(mist.meta.tracks);
+      }
+    }
+
+    this.metadata = merged;
+  }
+
+  private buildMetadataTracks(tracksObj: Record<string, unknown>): ContentMetadata['tracks'] {
+    const tracks: NonNullable<ContentMetadata['tracks']> = [];
+    for (const [, trackData] of Object.entries(tracksObj)) {
+      const t = trackData as Record<string, unknown>;
+      const trackType = t.type as string;
+      if (trackType !== 'video' && trackType !== 'audio' && trackType !== 'meta') {
+        continue;
+      }
+
+      const bitrate = typeof t.bps === 'number' ? Math.round(t.bps) : undefined;
+      const fps = typeof t.fpks === 'number' ? t.fpks / 1000 : undefined;
+
+      tracks.push({
+        type: trackType,
+        codec: t.codec as string | undefined,
+        width: t.width as number | undefined,
+        height: t.height as number | undefined,
+        bitrate,
+        fps,
+        channels: t.channels as number | undefined,
+        sampleRate: t.rate as number | undefined,
+      });
+    }
+    return tracks.length ? tracks : undefined;
+  }
+
+  private sanitizeMistInfo(info: MistStreamInfo): MistStreamInfo {
+    const sanitized: MistStreamInfo = {
+      error: info.error,
+      on_error: info.on_error,
+      perc: info.perc,
+      type: info.type,
+      hasVideo: info.hasVideo,
+      hasAudio: info.hasAudio,
+      unixoffset: info.unixoffset,
+      lastms: info.lastms,
+    };
+
+    if (info.source) {
+      sanitized.source = info.source.map((src) => ({
+        url: src.url,
+        type: src.type,
+        priority: src.priority,
+        simul_tracks: src.simul_tracks,
+        relurl: src.relurl,
+      }));
+    }
+
+    if (info.meta) {
+      sanitized.meta = {
+        buffer_window: info.meta.buffer_window,
+        duration: info.meta.duration,
+        mistUrl: info.meta.mistUrl,
+      };
+
+      if (info.meta.tracks) {
+        const tracks: Record<string, any> = {};
+        for (const [key, track] of Object.entries(info.meta.tracks)) {
+          tracks[key] = {
+            type: track.type,
+            codec: track.codec,
+            width: track.width,
+            height: track.height,
+            bps: track.bps,
+            fpks: track.fpks,
+            codecstring: track.codecstring,
+            firstms: track.firstms,
+            lastms: track.lastms,
+            lang: track.lang,
+            idx: track.idx,
+            channels: track.channels,
+            rate: track.rate,
+            size: track.size,
+          };
+        }
+        sanitized.meta.tracks = tracks;
+      }
+    }
+
+    return sanitized;
   }
 
   /** Get stream info (sources + tracks for player selection) */
@@ -905,6 +1044,29 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
     return this._supportsPlaybackRate;
   }
 
+  /** Resolve content type from config override or Gateway metadata */
+  private getResolvedContentType(): ContentType | null {
+    if (this.config.contentType) {
+      return this.config.contentType;
+    }
+    const metadata = this.getMetadata();
+    const metaType = metadata?.contentType?.toLowerCase();
+    if (metaType === 'live' || metaType === 'clip' || metaType === 'dvr' || metaType === 'vod') {
+      return metaType as ContentType;
+    }
+    const mistType = this.streamState?.streamInfo?.type;
+    if (mistType === 'live' || mistType === 'vod') {
+      return mistType;
+    }
+    if (metadata?.isLive === true) {
+      return 'live';
+    }
+    if (metadata?.isLive === false) {
+      return 'vod';
+    }
+    return null;
+  }
+
   /** Check if source is WebRTC/MediaStream */
   isWebRTCSource(): boolean {
     return this._isWebRTC;
@@ -918,14 +1080,33 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
   /** Check if content is effectively live (live or DVR still recording) */
   isEffectivelyLive(): boolean {
-    const { contentType } = this.config;
+    const contentType = this.getResolvedContentType() ?? 'live';
     const metadata = this.getMetadata();
-    return contentType === 'live' || (contentType === 'dvr' && metadata?.dvrStatus === 'recording');
+
+    // Explicit VOD content types are never live
+    if (contentType === 'vod' || contentType === 'clip') {
+      return false;
+    }
+
+    // If Gateway metadata says it's not live, trust it
+    if (metadata?.isLive === false) {
+      return false;
+    }
+
+    // DVR that's finished recording is not live
+    if (contentType === 'dvr' && metadata?.dvrStatus === 'completed') {
+      return false;
+    }
+
+    // Default: trust contentType or duration-based detection
+    return contentType === 'live' ||
+           (contentType === 'dvr' && metadata?.dvrStatus === 'recording') ||
+           !Number.isFinite(this.getDuration());
   }
 
   /** Check if content is strictly live (not DVR/clip/vod) */
   isLive(): boolean {
-    return this.config.contentType === 'live';
+    return (this.getResolvedContentType() ?? 'live') === 'live';
   }
 
   /**
@@ -935,7 +1116,9 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
    * DVR-while-recording needs cold start because MistServer may not be serving the VOD yet
    */
   needsColdStart(): boolean {
-    return this.config.contentType !== 'live';
+    const contentType = this.getResolvedContentType();
+    if (!contentType) return true;
+    return contentType !== 'live';
   }
 
   /**
@@ -1509,7 +1692,6 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
     // Check if values changed
     const seekableChanged = this._seekableStart !== seekableStart || this._liveEdge !== liveEdge;
-    const canSeekChanged = this._canSeek !== this._canSeek; // Already updated above
 
     this._seekableStart = seekableStart;
     this._liveEdge = liveEdge;
@@ -1933,11 +2115,12 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
   // ============================================================================
 
   private async resolveEndpoints(): Promise<void> {
-    const { endpoints, gatewayUrl, mistUrl, contentType, contentId, authToken } = this.config;
+    const { endpoints, gatewayUrl, mistUrl, contentId, authToken } = this.config;
 
     // Priority 1: Use pre-resolved endpoints if provided
     if (endpoints?.primary) {
       this.endpoints = endpoints;
+      this.setMetadataSeed(endpoints.metadata ?? null);
       this.setState('gateway_ready', { gatewayStatus: 'ready' });
       return;
     }
@@ -1950,7 +2133,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
     // Priority 3: Gateway resolution
     if (gatewayUrl) {
-      await this.resolveFromGateway(gatewayUrl, contentType, contentId, authToken);
+      await this.resolveFromGateway(gatewayUrl, contentId, authToken);
       return;
     }
 
@@ -1973,7 +2156,13 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
         throw new Error(`MistServer HTTP ${response.status}`);
       }
 
-      const data = await response.json();
+      // MistServer can return JSONP: callback({...}); - strip wrapper if present
+      let text = await response.text();
+      const jsonpMatch = text.match(/^[^(]+\(([\s\S]*)\);?$/);
+      if (jsonpMatch) {
+        text = jsonpMatch[1];
+      }
+      const data = JSON.parse(text);
 
       if (data.error) {
         throw new Error(data.error);
@@ -2008,6 +2197,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
       };
 
       this.endpoints = { primary, fallbacks: [] };
+      this.setMetadataSeed(null);
 
       // Parse track metadata from MistServer response
       if (data.meta?.tracks && typeof data.meta.tracks === 'object') {
@@ -2031,11 +2221,17 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
    */
   private mapMistTypeToProtocol(mistType: string): string {
     // WebCodecs raw streams - check BEFORE generic ws/ catch-all
-    // MistServer rawws.js uses 'ws/video/raw', mews.js uses 'ws/video/mp4' and 'ws/video/webm'
     if (mistType === 'ws/video/raw') return 'RAW_WS';
     if (mistType === 'wss/video/raw') return 'RAW_WSS';
-    // MEWS (MP4/WebM over WebSocket) - catches remaining ws/* types
-    if (mistType.startsWith('ws/') || mistType.startsWith('wss/')) return 'MEWS_WS';
+    // Annex B H264 over WebSocket (video-only, uses same 12-byte header as raw)
+    if (mistType === 'ws/video/h264') return 'H264_WS';
+    if (mistType === 'wss/video/h264') return 'H264_WSS';
+    // WebM over WebSocket - check BEFORE generic ws/ catch-all
+    if (mistType === 'ws/video/webm') return 'MEWS_WEBM';
+    if (mistType === 'wss/video/webm') return 'MEWS_WEBM_SSL';
+    // MEWS MP4 over WebSocket - catch remaining ws/* types (defaults to mp4)
+    if (mistType.startsWith('ws/')) return 'MEWS_WS';
+    if (mistType.startsWith('wss/')) return 'MEWS_WSS';
     if (mistType.includes('webrtc')) return 'MIST_WEBRTC';
     if (mistType.includes('mpegurl') || mistType.includes('m3u8')) return 'HLS';
     if (mistType.includes('dash') || mistType.includes('mpd')) return 'DASH';
@@ -2064,7 +2260,6 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
    */
   private async resolveFromGateway(
     gatewayUrl: string,
-    contentType: ContentType,
     contentId: string,
     authToken?: string
   ): Promise<void> {
@@ -2072,7 +2267,6 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
     this.gatewayClient = new GatewayClient({
       gatewayUrl,
-      contentType,
       contentId,
       authToken,
     });
@@ -2088,6 +2282,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
 
     try {
       this.endpoints = await this.gatewayClient.resolve();
+      this.setMetadataSeed(this.endpoints?.metadata ?? null);
       this.setState('gateway_ready', { gatewayStatus: 'ready' });
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Gateway resolution failed';
@@ -2097,10 +2292,17 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
   }
 
   private startStreamStatePolling(): void {
-    const { contentType, contentId, mistUrl } = this.config;
+    const { contentId, mistUrl } = this.config;
+    const contentType = this.getResolvedContentType();
 
     // Only poll for live-like content. DVR should only poll while recording.
-    if (contentType !== 'live' && contentType !== 'dvr') return;
+    // If contentType is unknown but mistUrl is provided, still poll so we can
+    // detect when a stream comes online and initialize playback.
+    if (contentType == null) {
+      if (!mistUrl) return;
+    } else if (contentType !== 'live' && contentType !== 'dvr') {
+      return;
+    }
     if (contentType === 'dvr') {
       const dvrStatus = this.getMetadata()?.dvrStatus;
       if (dvrStatus && dvrStatus !== 'recording') return;
@@ -2145,6 +2347,9 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
         }
       }
 
+      // Merge Mist metadata into the unified metadata surface
+      this.refreshMergedMetadata();
+
       this.emit('streamStateChange', { state });
 
       // Auto-play when stream transitions from offline to online
@@ -2213,6 +2418,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
       };
 
       this.endpoints = { primary, fallbacks: [] };
+      this.setMetadataSeed(this.endpoints.metadata ?? null);
 
       // Parse track metadata from stream info
       if (streamInfo.meta?.tracks && typeof streamInfo.meta.tracks === 'object') {
@@ -2373,7 +2579,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
         this.initializeSubControllers();
         this.emit('ready', { videoElement: el });
       },
-      onTimeUpdate: (t) => {
+      onTimeUpdate: (_t) => {
         if (this.isDestroyed) return;
         // Defensive: keep video element attached even if some other lifecycle cleared the container.
         // (Playback can continue even when detached, which looks like "audio only".)
@@ -2663,7 +2869,7 @@ export class PlayerController extends TypedEventEmitter<PlayerControllerEvents>
         if (playerName === 'webcodecs') {
           this.suppressPlayPauseEvents(250);
         }
-        if (hasFrameStep && player) {
+        if (hasFrameStep && player && player.frameStep) {
           player.frameStep(direction, seconds);
           return true;
         }

package/src/core/PlayerInterface.ts

@@ -61,6 +61,12 @@ export interface PlayerOptions {
   onPlaying?: () => void;
   onCanPlay?: () => void;
   onDurationChange?: (duration: number) => void;
+  /** HLS.js configuration override (merged with defaults) */
+  hlsConfig?: Record<string, unknown>;
+  /** DASH.js configuration override (merged with defaults) */
+  dashConfig?: Record<string, unknown>;
+  /** Video.js VHS configuration override (merged with defaults) */
+  vhsConfig?: Record<string, unknown>;
 }
 
 export interface PlayerCapability {

package/src/core/PlayerManager.ts

@@ -349,6 +349,14 @@ export class PlayerManager {
     selectionSources.forEach((s, idx) => selectionIndexBySource.set(s, idx));
     const totalSources = selectionSources.length;
 
+    const requiredTracks: Array<'video' | 'audio'> = [];
+    if (streamInfo.meta.tracks.some((t) => t.type === 'video')) {
+      requiredTracks.push('video');
+    }
+    if (streamInfo.meta.tracks.some((t) => t.type === 'audio')) {
+      requiredTracks.push('audio');
+    }
+
     // Track seen player+sourceType pairs to avoid duplicates
     const seenPairs = new Set<string>();
 
@@ -439,6 +447,47 @@ export class PlayerManager {
           continue;
         }
 
+        if (Array.isArray(tracktypes) && requiredTracks.length > 0) {
+          const missing = requiredTracks.filter((t) => !tracktypes.includes(t));
+          if (missing.length > 0) {
+            const priorityScore =
+              1 - player.capability.priority / Math.max(maxPriority, 1);
+            const sourceScore =
+              1 - sourceListIndex / Math.max(totalSources - 1, 1);
+            const playerScore = scorePlayer(
+              tracktypes,
+              player.capability.priority,
+              sourceListIndex,
+              {
+                maxPriority,
+                totalSources,
+                playerShortname: player.capability.shortname,
+                mimeType: source.type,
+                playbackMode: effectiveMode,
+              }
+            );
+
+            combinations.push({
+              player: player.capability.shortname,
+              playerName: player.capability.name,
+              source,
+              sourceIndex,
+              sourceType: source.type,
+              score: playerScore.total,
+              compatible: false,
+              incompatibleReason: `Missing required tracks: ${missing.join(', ')}`,
+              scoreBreakdown: {
+                trackScore: 0,
+                trackTypes: tracktypes,
+                priorityScore,
+                sourceScore,
+                weights: { tracks: 0.5, priority: 0.1, source: 0.05 },
+              },
+            });
+            continue;
+          }
+        }
+
         // Compatible - calculate full score
         const trackScore = Array.isArray(tracktypes)
           ? tracktypes.reduce(

package/src/core/StreamStateClient.ts

@@ -114,7 +114,7 @@ function getStatusMessage(status: StreamStatus, percentage?: number): string {
  * ```typescript
  * const client = new StreamStateClient({
  *   mistBaseUrl: 'https://mist.example.com',
- *   streamName: 'my-stream',
+ *   streamName: 'pk_...', // playbackId (view key)
  * });
  *
  * client.on('stateChange', ({ state }) => console.log('State:', state));
@@ -291,7 +291,7 @@ export class StreamStateClient extends TypedEventEmitter<StreamStateClientEvents
         .replace(/^https:/, 'wss:')
         .replace(/\/$/, '');
 
-      const ws = new WebSocket(`${wsUrl}/json_${encodeURIComponent(streamName)}.js`);
+      const ws = new WebSocket(`${wsUrl}/json_${encodeURIComponent(streamName)}.js?metaeverywhere=1&inclzero=1`);
       this.ws = ws;
 
       ws.onopen = () => {
@@ -337,7 +337,7 @@ export class StreamStateClient extends TypedEventEmitter<StreamStateClientEvents
     const { mistBaseUrl, streamName, pollInterval } = this.config;
 
     try {
-      const url = `${mistBaseUrl.replace(/\/$/, '')}/json_${encodeURIComponent(streamName)}.js`;
+      const url = `${mistBaseUrl.replace(/\/$/, '')}/json_${encodeURIComponent(streamName)}.js?metaeverywhere=1&inclzero=1`;
       const response = await fetch(url, {
         method: 'GET',
         headers: { 'Accept': 'application/json' },

package/src/core/SubtitleManager.ts

@@ -246,7 +246,7 @@ export class SubtitleManager {
     for (const cue of newCues) {
       try {
         textTrack.addCue(cue);
-      } catch (e) {
+      } catch {
         // Ignore errors from invalid cue timing
       }
     }

package/src/core/TelemetryReporter.ts

@@ -1,4 +1,4 @@
-import type { TelemetryPayload, TelemetryOptions, PlaybackQuality, ContentType } from '../types';
+import type { TelemetryPayload, PlaybackQuality, ContentType } from '../types';
 
 /**
  * Generate a unique session ID

package/src/core/TimerManager.ts

@@ -140,7 +140,7 @@ export class TimerManager {
   stopAll(): void {
     const count = this.timers.size;
 
-    for (const [internalId, entry] of this.timers) {
+    for (const [_internalId, entry] of this.timers) {
       if (entry.isInterval) {
         clearInterval(entry.id);
       } else {

package/src/core/scorer.ts

@@ -182,6 +182,9 @@ export const PROTOCOL_PENALTIES: Record<string, number> = {
   // MEWS - heavy penalty, prefer HLS/WebRTC (reference mews.js has issues)
   'ws/video/mp4': 0.50,
   'wss/video/mp4': 0.50,
+  // Native Mist WebRTC signaling - treat like MEWS (legacy/less stable than WHEP)
+  'webrtc': 0.50,
+  'mist/webrtc': 0.50,
   // DASH - heavy penalty, broken implementation
   'dash/video/mp4': 0.90,  // Below legacy
   'dash/video/webm': 0.95,
@@ -258,8 +261,8 @@ export const MODE_PROTOCOL_BONUSES: Record<PlaybackMode, Record<string, number>>
     'wss/video/h264': 0.52,
     // WHEP/WebRTC: sub-second latency
     'whep': 0.50,
-    'webrtc': 0.45,
-    'mist/webrtc': 0.45,
+    'webrtc': 0.25,
+    'mist/webrtc': 0.25,
     // MP4/WS (MEWS): 2-5s latency, good fallback
     'ws/video/mp4': 0.30,
     'wss/video/mp4': 0.30,
@@ -283,6 +286,7 @@ export const MODE_PROTOCOL_BONUSES: Record<PlaybackMode, Record<string, number>>
     // WebRTC: minimal for quality mode
     'whep': 0.05,
     'webrtc': 0.05,
+    'mist/webrtc': 0.05,
   },
   'vod': {
     // VOD/Clip: Prefer seekable protocols, EXCLUDE WebRTC (no seek support)
@@ -306,8 +310,8 @@ export const MODE_PROTOCOL_BONUSES: Record<PlaybackMode, Record<string, number>>
     'html5/video/mp4': 0.42,
     // WHEP/WebRTC: good for low latency
     'whep': 0.38,
-    'webrtc': 0.35,
-    'mist/webrtc': 0.35,
+    'webrtc': 0.20,
+    'mist/webrtc': 0.20,
     // MP4/WS (MEWS): lower latency than HLS
     'ws/video/mp4': 0.30,
     'wss/video/mp4': 0.30,