prismcast 1.5.2 → 1.7.0

package/dist/streaming/monitor.js

@@ -1,32 +1,27 @@
-import { EvaluateTimeoutError, LOG, formatError, getAbortSignal, isSessionClosedError, runWithStreamContext, startTimer } from "../utils/index.js";
-import { RECOVERY_METHODS, capitalize, checkCircuitBreaker, createRecoveryMetrics, formatIssueType, formatRecoveryDuration, getIssueCategory, getIssueDescription, getRecoveryMethod, recordRecoveryAttempt, recordRecoverySuccess, resetCircuitBreaker } from "./recovery.js";
+import { EvaluateTimeoutError, LOG, capitalize, formatError, getAbortSignal, isSessionClosedError, runWithStreamContext, startTimer } from "../utils/index.js";
+import { RECOVERY_METHODS, checkCircuitBreaker, createRecoveryMetrics, formatIssueType, formatRecoveryDuration, getIssueCategory, getIssueDescription, getRecoveryMethod, recordRecoveryAttempt, recordRecoverySuccess, resetCircuitBreaker } from "./recovery.js";
 import { applyVideoStyles, buildVideoSelectorType, checkVideoPresence, enforceVideoVolume, ensurePlayback, findVideoContext, getVideoState, tuneToChannel, validateVideoElement, verifyFullscreen } from "../browser/video.js";
-import { getChannelLogo, getShowName } from "./showInfo.js";
-import { getLastSegmentSize, getStream, getStreamMemoryUsage } from "./registry.js";
+import { getLastSegmentHasVideo, getLastSegmentSize, getStream, getStreamMemoryUsage } from "./registry.js";
 import { CONFIG } from "../config/index.js";
+import { clearProbeCache } from "../native/probe.js";
 import { emitStreamHealthChanged } from "./statusEmitter.js";
+import { getChannelLogo } from "../config/userChannels.js";
 import { getClientSummary } from "./clients.js";
+import { getEffectiveViewport } from "../config/presets.js";
+import { getProviderBySlug } from "../browser/channelSelection.js";
+import { getShowName } from "./showInfo.js";
+import { refreshNativeManifest } from "../native/index.js";
 import { resizeAndMinimizeWindow } from "../browser/cdp.js";
 export function monitorPlaybackHealth(page, context, profile, url, streamId, streamInfo, onCircuitBreak, onTabReplacement) {
-    /* Monitor state variables. These track the video's behavior over time and control recovery decisions.
+    /* Monitor state. These track the video's behavior over time and control recovery decisions. Mutable variables are organized into typed state objects by subsystem
+     * (recovery, segments, native health, resolution) to clarify ownership and interaction boundaries. Variables that don't belong to a specific subsystem remain as
+     * standalone declarations.
      */
     // The current page reference. This can change after tab replacement recovery, when the old tab is closed and a new one is created. We use a mutable variable so we
     // can update the reference after replacement.
     let currentPage = page;
     // The video's currentTime from the previous check. Used to detect whether the video is progressing. Null on first check since we have no previous value.
     let lastTime = null;
-    // Number of consecutive checks where currentTime did not advance. We require multiple consecutive stalls before triggering recovery to avoid reacting to momentary
-    // hiccups. Reset to 0 when progression is detected.
-    let stallCount = 0;
-    // Number of consecutive checks where the video reports paused state. Like stallCount, we require multiple consecutive paused checks (> stallCountThreshold) before
-    // triggering recovery. This filters out transient rebuffer pauses where the player briefly pauses itself to refill its buffer and resumes on its own. Without this
-    // hysteresis, every transient rebuffer pause triggers an unnecessary L1 recovery (play/unmute) that logs noise but does nothing useful.
-    let pauseCount = 0;
-    // Current escalation level (0-4). Level 0 means no recovery needed. Each time recovery is triggered, this increments to try increasingly aggressive actions.
-    // Resets to 0 after sustained healthy playback.
-    let escalationLevel = 0;
-    // Timestamp of the last recovery attempt. Used to calculate healthy playback duration for escalation reset.
-    let lastRecoveryTime = 0;
     // Timestamp when buffering started, or null if not currently buffering. Used to apply the buffering grace period - we don't trigger recovery for buffering until
     // it exceeds BUFFERING_GRACE_PERIOD.
     let bufferingStartTime = null;
@@ -35,21 +30,6 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
     // Counter for consecutive page navigation failures. If navigation fails twice in a row, we fall back to source reload (level 2) instead. This prevents getting
     // stuck in a loop when navigation itself is the problem.
     let consecutiveNavigationFailures = 0;
-    // Track whether source reload (L2) has been attempted in the current page session. Log analysis shows the first source reload often works (~58%), but the second
-    // always fails and leaves the video at readyState=0. When this flag is true and recovery is needed, we skip L2 and go directly to L3 (page reload).
-    let sourceReloadAttempted = false;
-    // Segment production monitoring state. After L2/L3 recovery, we track whether segments are actually being produced. If recovery reports success but the capture
-    // pipeline is dead (MediaRecorder stopped producing data), we need to escalate to tab replacement.
-    let preRecoverySegmentIndex = null; // Segment index when recovery started, used to detect if new segments are produced.
-    let segmentWaitStartTime = null; // Timestamp when we started waiting for segment production after recovery grace period.
-    let segmentProductionStalled = false; // Flag indicating segment production has stalled after recovery.
-    // Continuous segment size and staleness monitoring state. Detects spontaneous capture pipeline death (no preceding recovery event) by checking segment sizes and
-    // production rate. Dead pipelines may produce tiny segments (18 bytes observed) or stop producing segments entirely, while the video element appears healthy. This
-    // complements post-recovery index monitoring.
-    let lastCheckedSegmentIndex = 0; // Last segment index we inspected (to detect new segments).
-    let lastSegmentAdvanceTime = Date.now(); // Timestamp when segment index last advanced. Used for staleness detection.
-    let consecutiveTinySegments = 0; // Count of consecutive tiny segments.
-    let wasInTinySegmentState = false; // For detecting spontaneous recovery (tiny→valid transition without explicit recovery).
     // Track whether the browser window needs to be re-minimized after recovery. Recovery actions (especially ensureFullscreen) can cause the window to un-minimize.
     // We set this flag when recovery is triggered and clear it after the recovery grace period passes and we see a healthy check.
     let pendingReMinimize = false;
@@ -59,8 +39,6 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
     let fullscreenReapplyCount = 0;
     // Flag indicating the cleanup function was called. When true, the next interval check will clear itself.
     let intervalCleared = false;
-    // Flag indicating a recovery operation is in progress. We skip health checks during recovery to avoid triggering additional recovery while one is running.
-    let recoveryInProgress = false;
     // The current video context (page or frame). This can change after a page navigation recovery, when we need to find the new video context.
     let currentContext = context;
     // Circuit breaker state. Tracks total failures within a time window and trips (terminates the stream) when too many failures occur.
@@ -71,8 +49,6 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
     // Counter for consecutive evaluate timeouts. When the browser tab becomes unresponsive, evaluate() calls will timeout instead of returning data. After 3
     // consecutive timeouts, we trigger tab replacement recovery (if the callback is provided). Reset to 0 on successful getVideoState().
     let consecutiveTimeouts = 0;
-    // Total recovery attempts for status reporting.
-    let totalRecoveryAttempts = 0;
     // Last known video state for status reporting.
     let lastVideoState = null;
     // Recovery metrics tracked throughout the stream's lifetime.
@@ -90,15 +66,28 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
     // segments contain only audio data. Audio is transcoded at a controlled bitrate (max 512Kbps), so audio-only segments are at most ~192KB for 3-second segments.
     // The 500KB threshold catches both dead captures (18 bytes) and audio-only captures while staying well below the smallest video preset (480p/3Mbps ≈ 750KB/segment).
     const TINY_SEGMENT_THRESHOLD = 512000; // 500KB - segments below this indicate dead or degraded capture.
-    const TINY_SEGMENT_COUNT_TRIGGER = 10; // Trigger recovery after 10 consecutive tiny segments (~20 seconds with 2-second segments).
+    const TINY_SEGMENT_COUNT_TRIGGER = 10; // Default trigger count: 10 consecutive tiny segments (~20 seconds with 2-second segments).
+    // Resolve the provider-specific tiny segment count threshold once at monitor startup. Providers with extended static content (e.g., Xfinity commercial
+    // placeholders) set a higher value to tolerate longer periods of small segments without false positive tab replacements. Dead capture pipelines (segments with
+    // no video trafs) always use TINY_SEGMENT_COUNT_TRIGGER regardless of this setting.
+    const providerModule = streamInfo.providerTag ? getProviderBySlug(streamInfo.providerTag) : undefined;
+    const providerTinySegmentThreshold = providerModule?.tinySegmentThreshold ?? TINY_SEGMENT_COUNT_TRIGGER;
     // Segment staleness timeout. When no new segments have been produced for this duration, the capture pipeline is considered dead even though the video element may
     // appear healthy. This catches the case where Chrome's MediaRecorder silently stops emitting data without raising an error — the input stream stays "open" but no
     // data events fire. The 20-second threshold is 4x the maximum expected moof delivery interval (5 seconds) to avoid false positives during normal bursty delivery.
     const SEGMENT_STALENESS_TIMEOUT = 20000; // 20 seconds.
+    // Resolution degradation detection. When the video element's intrinsic resolution is significantly below the configured viewport, the provider's ABR is delivering
+    // low-quality content. The threshold is expressed as a ratio — if either dimension is below this fraction of the viewport, the resolution is considered degraded.
+    // 50% catches clear ABR degradation (768×432 on 1080p = 40%) while allowing legitimate 720p content on 1080p (67% > 50%).
+    const RESOLUTION_RATIO_THRESHOLD = 0.5;
+    // Grace period in milliseconds after stream start and after each recovery action. Gives ABR time to ramp up before flagging degradation.
+    const RESOLUTION_GRACE_PERIOD = 30000;
+    // Number of consecutive degraded readings required before triggering recovery. At ~2 seconds per monitor tick, 15 readings = ~30 seconds of sustained
+    // degradation. This lets transient ABR dips (commercial breaks, ad transitions) self-heal without unnecessary page reloads.
+    const RESOLUTION_DEGRADED_COUNT_THRESHOLD = 15;
     // Fixed margin in milliseconds before the maxContinuousPlayback limit at which a proactive reload is triggered. Two minutes provides enough time for page
     // navigation and video reinitialization to complete before the site enforces its cutoff.
     const PROACTIVE_RELOAD_MARGIN_MS = 120000;
-    let recoveryGraceUntil = 0;
     // Timestamp of the most recent full page navigation. Used to calculate elapsed continuous playback for proactive reload when maxContinuousPlayback is configured.
     // Initialized to Date.now() because the monitor starts immediately after tuneToChannel() succeeds in stream setup, meaning a page load just completed. Reset
     // after any successful page navigation recovery or tab replacement, but NOT after source reloads (L2) which preserve the page's JavaScript context.
@@ -107,6 +96,265 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
     const selectorType = buildVideoSelectorType(profile);
     // Capture stream context for re-establishing on each interval tick. AsyncLocalStorage context is lost when entering setInterval callbacks.
     const streamContext = { channelName: streamInfo.channelName ?? undefined, streamId, url };
+    // Recovery state. Tracks escalation level, failure counters, and recovery lifecycle flags that control the decision to trigger recovery and which method to use.
+    const recoveryState = {
+        escalationLevel: 0,
+        graceUntil: 0,
+        inProgress: false,
+        lastRecoveryTime: 0,
+        pauseCount: 0,
+        sourceReloadAttempted: false,
+        stallCount: 0,
+        totalAttempts: 0
+    };
+    // Segment production state. Tracks both post-recovery segment verification and continuous segment size monitoring. After L2/L3 recovery, we verify segments are
+    // actually being produced. Independently, we monitor segment sizes on every tick to detect spontaneous capture pipeline death (dead pipelines produce tiny segments
+    // while the video element appears healthy).
+    const segmentState = {
+        consecutiveTinySegments: 0,
+        lastCheckedIndex: 0,
+        lastSegmentAdvanceTime: Date.now(),
+        preRecoveryIndex: null,
+        productionStalled: false,
+        waitStartTime: null,
+        wasInTinyState: false
+    };
+    // Native stream health state. Only used when the stream is in native mode. Tracks segment delivery health to detect stalled streams where the provider's manifest
+    // stops advancing or segments stop arriving. Native recovery uses recoveryState.inProgress rather than a separate flag, since the interval callback already checks
+    // that flag before dispatching to either the native or capture-mode health check path.
+    const nativeHealthState = {
+        issueTime: null,
+        issueType: null,
+        lastCheckedSegmentIndex: 0,
+        lastSegmentAdvanceTime: Date.now(),
+        recoveryAttempts: 0
+    };
+    // Resolution degradation monitoring. Separate from the recovery escalation (L1-L4) which handles broken playback. Resolution degradation is a quality issue - the
+    // stream works but at lower-than-expected resolution. Uses its own tracking and two-step escalation: page reload, then tab replacement.
+    const resolutionState = {
+        consecutiveDegradedReadings: 0,
+        graceEnd: Date.now() + RESOLUTION_GRACE_PERIOD,
+        recoveryAttempt: 0
+    };
+    /**
+     * Checks segment delivery health for native streams. Detects stalled streams by comparing the proxy's segment index and last segment timestamp against thresholds.
+     * Recovery follows three escalation levels per the plan:
+     *
+     * - L1: Re-fetch manifest (handled by the proxy's internal retry loop — consecutive failures up to the threshold)
+     * - L2: Reload page for fresh tokens (same mechanism as proactive token refresh, but triggered by segment staleness)
+     * - L3: Fall back to capture mode via tab replacement (stops native proxy, creates fresh page with capture pipeline)
+     *
+     * Note: The `recoveryState.inProgress` guard at the top of the interval callback prevents re-entry during async L2/L3 recovery. The native path does not need its
+     * own guard — it reuses the shared flag.
+     *
+     * @param entry - The stream registry entry for the native stream.
+     */
+    function checkNativeStreamHealth(entry) {
+        const proxy = entry.nativeProxy;
+        if (!proxy) {
+            emitStatusUpdate();
+            return;
+        }
+        const now = Date.now();
+        const currentSegmentIndex = proxy.getSegmentIndex();
+        const lastSegmentTime = proxy.getLastSegmentTime();
+        const targetDuration = proxy.getTargetDuration();
+        const consecutiveErrors = proxy.getConsecutiveErrors();
+        const storeKey = entry.info.storeKey;
+        // Fast path: if the proxy hit its error threshold and stopped itself, trigger L3 fallback immediately. This avoids waiting for the staleness threshold when hard
+        // errors (HTTP 403, network failures) have already been detected by the proxy's internal retry loop.
+        if (proxy.hasErrored()) {
+            LOG.debug("native:monitor", "Native proxy errored for %s. Initiating capture fallback.", storeKey);
+            nativeHealthState.issueType = "proxy error";
+            nativeHealthState.issueTime = now;
+            void runWithStreamContext(streamContext, async () => {
+                await executeNativeL3Fallback(entry);
+            });
+            return;
+        }
+        // Check if new segments have been produced since the last tick.
+        if (currentSegmentIndex > nativeHealthState.lastCheckedSegmentIndex) {
+            nativeHealthState.lastCheckedSegmentIndex = currentSegmentIndex;
+            nativeHealthState.lastSegmentAdvanceTime = now;
+            // Clear any previous issue tracking when segments are flowing.
+            if (nativeHealthState.issueType) {
+                nativeHealthState.issueType = null;
+                nativeHealthState.issueTime = null;
+                nativeHealthState.recoveryAttempts = 0;
+                LOG.debug("native:monitor", "Native stream healthy for %s. Segments advancing (index %s).", storeKey, currentSegmentIndex);
+            }
+        }
+        // Calculate staleness: time since the last new segment was produced.
+        const stalenessMs = now - nativeHealthState.lastSegmentAdvanceTime;
+        const stalenessThreshold = targetDuration * 2 * 1000;
+        // Classify health based on segment delivery metrics.
+        let nativeHealth = "healthy";
+        if (consecutiveErrors > 0) {
+            nativeHealth = "recovering";
+            if (!nativeHealthState.issueType) {
+                nativeHealthState.issueType = "fetch errors";
+                nativeHealthState.issueTime = now;
+            }
+            LOG.debug("native:monitor", "Native stream recovering for %s. Consecutive errors: %s.", storeKey, consecutiveErrors);
+        }
+        else if ((stalenessMs > stalenessThreshold) && (lastSegmentTime > 0)) {
+            // Only flag staleness after at least one segment has been produced (lastSegmentTime > 0) and the staleness exceeds the threshold.
+            nativeHealth = "stalled";
+            if (!nativeHealthState.issueType) {
+                nativeHealthState.issueType = "segment stall";
+                nativeHealthState.issueTime = now;
+            }
+            const staleSec = Math.round(stalenessMs / 1000);
+            LOG.debug("native:monitor", "Native stream stalled for %s. No new segments in %ss (threshold: %ss).", storeKey, staleSec, Math.round(stalenessThreshold / 1000));
+            // L2: At 4× target duration, attempt a page reload for fresh tokens. This recovers from auth expiry where the manifest URL is still valid but segment URLs
+            // are rejected. The proxy continues serving cached segments during the reload.
+            if ((stalenessMs > (targetDuration * 4 * 1000)) && (nativeHealthState.recoveryAttempts === 0)) {
+                LOG.warn("Native stream stalled for %s. No new segments in %ss. Attempting recovery.", storeKey, staleSec);
+                nativeHealthState.recoveryAttempts++;
+                void runWithStreamContext(streamContext, async () => {
+                    await executeNativeL2Recovery(entry);
+                });
+                return;
+            }
+            // L3: At 6× target duration (or if L2 was already attempted), fall back to capture mode via tab replacement.
+            if ((stalenessMs > (targetDuration * 6 * 1000)) || ((stalenessMs > (targetDuration * 4 * 1000)) && (nativeHealthState.recoveryAttempts > 0))) {
+                LOG.warn("Falling back to capture mode for %s: native streaming stalled after recovery attempt.", storeKey);
+                void runWithStreamContext(streamContext, async () => {
+                    await executeNativeL3Fallback(entry);
+                });
+                return;
+            }
+        }
+        emitNativeStatus(entry, nativeHealth);
+    }
+    /**
+     * Emits a status update with native-specific health classification. Populates meaningful fields (health, issue tracking, memory, clients) and zeroes video-specific
+     * fields that are not applicable to native streams.
+     *
+     * @param entry - The stream registry entry.
+     * @param health - The health status to report.
+     */
+    function emitNativeStatus(entry, health) {
+        if (intervalCleared) {
+            return;
+        }
+        const now = Date.now();
+        const memoryBytes = getStreamMemoryUsage(entry).total;
+        const channelKey = entry.info.storeKey;
+        const clientSummary = getClientSummary(streamInfo.numericStreamId);
+        const escalation = (health === "stalled") ? 1 : ((health === "recovering") ? 2 : 0);
+        const status = {
+            bufferingDuration: null,
+            captureCodec: entry.captureCodec,
+            channel: streamInfo.channelName,
+            clientCount: clientSummary.total,
+            clients: clientSummary.clients,
+            currentTime: 0,
+            duration: Math.round((now - streamInfo.startTime.getTime()) / 1000),
+            escalationLevel: escalation,
+            hardwareAccelerated: entry.hardwareAccelerated,
+            health,
+            id: streamInfo.numericStreamId,
+            lastIssueTime: nativeHealthState.issueTime,
+            lastIssueType: nativeHealthState.issueType,
+            lastRecoveryTime: null,
+            logoUrl: channelKey ? (getChannelLogo(channelKey) ?? "") : "",
+            memoryBytes,
+            nativeBandwidth: entry.nativeBandwidth,
+            nativeResolution: entry.nativeResolution,
+            networkState: 0,
+            pageReloadsInWindow: 0,
+            providerName: streamInfo.providerName,
+            readyState: 0,
+            recoveryAttempts: nativeHealthState.recoveryAttempts,
+            showName: getShowName(streamInfo.numericStreamId),
+            startTime: streamInfo.startTime.toISOString(),
+            streamingMode: entry.streamingMode,
+            url
+        };
+        emitStreamHealthChanged(status);
+    }
+    /**
+     * L2 recovery for native streams: reloads the page to get fresh authentication tokens and re-intercepts the manifest. Delegates to the shared refreshNativeManifest
+     * helper in the coordinator module, which handles interceptor installation, navigation, probing, isStopped() guards, and proxy updates.
+     *
+     * @param entry - The stream registry entry.
+     */
+    async function executeNativeL2Recovery(entry) {
+        const proxy = entry.nativeProxy;
+        if (!proxy || proxy.isStopped()) {
+            return;
+        }
+        recoveryState.inProgress = true;
+        LOG.debug("native:monitor", "Starting L2 recovery (page reload) for %s.", entry.info.storeKey);
+        try {
+            const success = await refreshNativeManifest({
+                channelName: entry.info.storeKey,
+                page: currentPage,
+                proxy,
+                streamIdStr: streamId,
+                url
+            });
+            if (success) {
+                // Reset staleness tracking so the monitor gives the refreshed stream time to produce segments.
+                nativeHealthState.lastSegmentAdvanceTime = Date.now();
+            }
+        }
+        finally {
+            recoveryState.inProgress = false;
+        }
+    }
+    /**
+     * L3 recovery for native streams: falls back to capture mode via tab replacement. Stops the native proxy, creates a fresh page with capture pipeline, and switches
+     * the stream to capture mode. The existing tab replacement infrastructure handles page creation, capture initialization, segmenter creation, and registry updates.
+     *
+     * If the proxy's onError fires concurrently (from the poll loop hitting its failure threshold), terminateStream runs before this async function gets a chance to
+     * execute. By the time L3 runs, the stream is already terminated and executeTabReplacement returns null, which we handle as a failed outcome.
+     *
+     * @param entry - The stream registry entry.
+     */
+    async function executeNativeL3Fallback(entry) {
+        if (!onTabReplacement) {
+            LOG.warn("Capture fallback not available for %s: no tab replacement handler.", entry.info.storeKey);
+            onCircuitBreak();
+            return;
+        }
+        LOG.debug("native:monitor", "Starting L3 fallback (capture mode) for %s.", entry.info.storeKey);
+        // Stop the native proxy before tab replacement closes the page. The proxy may still be polling and would encounter errors when the page navigates away.
+        if (entry.nativeProxy) {
+            entry.nativeProxy.stop();
+            entry.nativeProxy = null;
+        }
+        // Use the existing tab replacement infrastructure. It sets recoveryState.inProgress = true internally and clears it in finalizeTabReplacement. It creates a new
+        // page with capture, navigates, sets up playback, creates a segmenter, and updates the registry entry (page, rawCaptureStream, ffmpegProcess, segmenter).
+        const outcome = await executeTabReplacement("native fallback to capture");
+        if (outcome.outcome === "success") {
+            // Tab replacement succeeded. Update the registry to reflect capture mode. The tab replacement handler already set page, rawCaptureStream, ffmpegProcess,
+            // and segmenter on the registry entry. We just need to update the streaming mode and clear audio state.
+            entry.streamingMode = "capture";
+            // Clear separate audio state from the native proxy. Without this, hasAudio remains true and the HLS handler continues serving the master playlist (referencing
+            // video.m3u8 and audio.m3u8) instead of the capture segmenter's variant playlist. Clients that cached the master playlist structure would request stale audio
+            // and video variant playlists pointing to segments that are no longer being updated.
+            entry.hls.hasAudio = false;
+            entry.hls.audioPlaylist = "";
+            entry.hls.audioSegments.clear();
+            entry.hls.audioSegmentBytes = 0;
+            entry.hls.videoPlaylist = "";
+            // Clear the probe cache so subsequent tunes to this channel don't re-attempt native streaming.
+            clearProbeCache(entry.info.storeKey);
+            LOG.info("Switched to capture mode for %s: native streaming failed.", entry.info.storeKey);
+            // The monitor's next tick will see streamingMode === "capture" and run the normal video element monitoring path. The state reset from
+            // applyTabReplacementSuccess (called by executeTabReplacement) already initialized all capture-mode monitor variables.
+        }
+        else if (outcome.outcome === "terminated") {
+            // Circuit breaker tripped during tab replacement. Stream is being terminated.
+            LOG.warn("Capture fallback failed for %s: circuit breaker tripped.", entry.info.storeKey);
+        }
+        else {
+            // Tab replacement failed but stream wasn't terminated. The circuit breaker will handle it on the next failure.
+            LOG.warn("Capture fallback failed for %s: tab replacement unsuccessful.", entry.info.storeKey);
+        }
+    }
     // Helper to mark a discontinuity in the HLS playlist after recovery events that disrupt the video source. The segmenter flushes its current fragment buffer and sets
     // a pending discontinuity flag so the next segment boundary includes an #EXT-X-DISCONTINUITY tag. This tells HLS clients to flush their decoder state.
     const markStreamDiscontinuity = () => {
@@ -122,11 +370,11 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
             return "error";
         }
         // If we're at escalation level 3 (page reload), we're in serious trouble.
-        if (escalationLevel >= 3) {
+        if (recoveryState.escalationLevel >= 3) {
             return "error";
         }
         // If we're actively recovering (levels 1-2).
-        if (escalationLevel > 0) {
+        if (recoveryState.escalationLevel > 0) {
             return "recovering";
         }
         // If we're buffering (within grace period).
@@ -134,7 +382,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
             return "buffering";
         }
         // If we have consecutive stalls but not yet triggering recovery.
-        if (stallCount > 0) {
+        if (recoveryState.stallCount > 0) {
             return "stalled";
         }
         return "healthy";
@@ -143,6 +391,12 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
      * Emits a status update for this stream.
      */
     function emitStatusUpdate() {
+        // Do not emit after the monitor has been stopped. An in-flight async tick can resume from an await after terminateStream() has called stopMonitor() and
+        // emitStreamRemoved(). Without this guard, the emitStreamHealthChanged() call below would re-add the dead stream to the streamStatuses Map, creating a zombie
+        // entry that persists in SSE snapshots indefinitely.
+        if (intervalCleared) {
+            return;
+        }
         const now = Date.now();
         // Get current memory usage from the stream's HLS segment buffers.
         const entry = getStream(streamInfo.numericStreamId);
@@ -153,26 +407,31 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
         const clientSummary = getClientSummary(streamInfo.numericStreamId);
         const status = {
             bufferingDuration: bufferingStartTime ? Math.round((now - bufferingStartTime) / 1000) : null,
+            captureCodec: entry?.captureCodec ?? null,
             channel: streamInfo.channelName,
             clientCount: clientSummary.total,
             clients: clientSummary.clients,
             currentTime: lastVideoState?.time ?? 0,
             duration: Math.round((now - streamInfo.startTime.getTime()) / 1000),
-            escalationLevel,
+            escalationLevel: recoveryState.escalationLevel,
+            hardwareAccelerated: entry?.hardwareAccelerated ?? false,
             health: computeHealthStatus(),
             id: streamInfo.numericStreamId,
             lastIssueTime,
             lastIssueType,
-            lastRecoveryTime: lastRecoveryTime > 0 ? lastRecoveryTime : null,
+            lastRecoveryTime: recoveryState.lastRecoveryTime > 0 ? recoveryState.lastRecoveryTime : null,
             logoUrl: channelKey ? (getChannelLogo(channelKey) ?? "") : "",
             memoryBytes,
+            nativeBandwidth: entry?.nativeBandwidth ?? 0,
+            nativeResolution: entry?.nativeResolution ?? null,
             networkState: lastVideoState?.networkState ?? 0,
             pageReloadsInWindow: pageReloadTimestamps.length,
             providerName: streamInfo.providerName,
             readyState: lastVideoState?.readyState ?? 0,
-            recoveryAttempts: totalRecoveryAttempts,
+            recoveryAttempts: recoveryState.totalAttempts,
             showName: getShowName(streamInfo.numericStreamId),
             startTime: streamInfo.startTime.toISOString(),
+            streamingMode: entry?.streamingMode ?? "capture",
             url
         };
         emitStreamHealthChanged(status);
@@ -182,7 +441,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
      * failure, and error). The flag must be reset before emitting status to prevent the monitor from getting stuck if emitStatusUpdate() throws.
      */
     function finalizeTabReplacement() {
-        recoveryInProgress = false;
+        recoveryState.inProgress = false;
         emitStatusUpdate();
     }
     /**
@@ -190,13 +449,13 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
      * monitoring and continuous size monitoring.
      */
     function resetSegmentMonitoringState() {
-        preRecoverySegmentIndex = null;
-        segmentWaitStartTime = null;
-        segmentProductionStalled = false;
-        consecutiveTinySegments = 0;
-        wasInTinySegmentState = false;
-        lastCheckedSegmentIndex = getStream(streamInfo.numericStreamId)?.segmenter?.getSegmentIndex() ?? 0;
-        lastSegmentAdvanceTime = Date.now();
+        segmentState.preRecoveryIndex = null;
+        segmentState.waitStartTime = null;
+        segmentState.productionStalled = false;
+        segmentState.consecutiveTinySegments = 0;
+        segmentState.wasInTinyState = false;
+        segmentState.lastCheckedIndex = getStream(streamInfo.numericStreamId)?.segmenter?.getSegmentIndex() ?? 0;
+        segmentState.lastSegmentAdvanceTime = Date.now();
     }
     /**
      * Resets all failure/retry counters to zero. Called after successful tab replacement or page navigation to give the stream a fresh start.
@@ -205,16 +464,38 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
         consecutiveTimeouts = 0;
         consecutiveNavigationFailures = 0;
         fullscreenReapplyCount = 0;
-        pauseCount = 0;
+        recoveryState.pauseCount = 0;
+        recoveryState.stallCount = 0;
         videoNotFoundCount = 0;
-        stallCount = 0;
+    }
+    /**
+     * Resets resolution monitoring state. Called when resolution reaches expected levels or after any recovery action that restarts ABR negotiation.
+     */
+    function resetResolutionState() {
+        resolutionState.consecutiveDegradedReadings = 0;
+        resolutionState.graceEnd = Date.now() + RESOLUTION_GRACE_PERIOD;
+        resolutionState.recoveryAttempt = 0;
+    }
+    /**
+     * Checks the page reload rate limit. Prunes expired timestamps, checks if the limit has been reached, and records the current timestamp if allowed. Callers are
+     * responsible for logging and handling the rate-limited case — consequences differ by context (circuit break, deferral, fallback to L2).
+     * @returns True if a page reload is allowed and the timestamp has been recorded, false if the rate limit has been reached.
+     */
+    function isPageReloadAllowed() {
+        const reloadWindow = Date.now() - CONFIG.playback.pageReloadWindow;
+        pageReloadTimestamps = pageReloadTimestamps.filter((ts) => ts > reloadWindow);
+        if (pageReloadTimestamps.length >= CONFIG.playback.maxPageReloads) {
+            return false;
+        }
+        pageReloadTimestamps.push(Date.now());
+        return true;
     }
     /**
      * Resets escalation level and related flags. Called after successful recovery to allow the stream to start from level 0 on future issues.
      */
     function resetEscalationState() {
-        escalationLevel = 0;
-        sourceReloadAttempted = false;
+        recoveryState.escalationLevel = 0;
+        recoveryState.sourceReloadAttempted = false;
     }
     /**
      * Sets the recovery grace period and re-minimize flag after a recovery action. The grace period prevents the monitor from immediately detecting new issues while the
@@ -223,7 +504,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
      */
     function setRecoveryGracePeriod(level) {
         pendingReMinimize = true;
-        recoveryGraceUntil = Date.now() + recoveryGracePeriods[level];
+        recoveryState.graceUntil = Date.now() + recoveryGracePeriods[level];
     }
     /**
      * Handles tab replacement failure by checking the circuit breaker. If the breaker trips, terminates the stream. Returns the appropriate outcome for the caller.
@@ -256,6 +537,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
         resetRecoveryCounters();
         resetEscalationState();
         resetSegmentMonitoringState();
+        resetResolutionState();
         setRecoveryGracePeriod(3);
         resetCircuitBreaker(circuitBreaker);
     }
@@ -298,9 +580,9 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
         if (!onTabReplacement) {
             return { outcome: "failed" };
         }
-        recoveryInProgress = true;
-        totalRecoveryAttempts++;
-        lastRecoveryTime = Date.now();
+        recoveryState.inProgress = true;
+        recoveryState.totalAttempts++;
+        recoveryState.lastRecoveryTime = Date.now();
         lastIssueType = issueType;
         lastIssueTime = Date.now();
         const tabRecoveryElapsed = startTimer();
@@ -390,16 +672,492 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
             return { success: false };
         }
     }
+    // Tick phase functions. Each implements one phase of the monitoring interval, closing over monitor state and taking per-tick computed values as parameters. Functions
+    // that can exit the tick return a boolean: true means the caller should return immediately, false means continue.
+    /**
+     * Handles the case where no video element was found in the current context. Applies a grace period before triggering recovery: first failure waits, second failure
+     * attempts frame re-search, third failure escalates to full page navigation. Distinguishes "no video element" from "video exists but not ready" (buffering).
+     *
+     * Always exits the tick — no path falls through to subsequent health checks.
+     * @param now - Current timestamp for timing calculations.
+     */
+    async function handleVideoNotFound(now) {
+        // Determine context type for diagnostic logging.
+        const contextType = currentContext === currentPage ? "main page" : "iframe";
+        const frameCount = currentPage.frames().length;
+        // Check video presence to distinguish between "no video" and "video exists but not ready".
+        let presence = null;
+        try {
+            presence = await checkVideoPresence(currentContext, selectorType);
+        }
+        catch (_error) {
+            // If presence check fails (context destroyed), treat as no video.
+        }
+        if (presence?.anyVideoExists && !presence.readyVideoFound) {
+            // Video element exists but doesn't meet readyState criteria. This is a buffering condition, not a missing video condition. Apply the normal buffering grace
+            // period instead of escalating to navigation.
+            LOG.debug("recovery:general", "Video is buffering (readyState=%s, elements=%s).", presence.maxReadyState, presence.videoCount);
+            // Reset video not found counter since video actually exists.
+            videoNotFoundCount = 0;
+            emitStatusUpdate();
+            return;
+        }
+        videoNotFoundCount++;
+        LOG.warn("Video element not found (attempt %s/3). Context: %s, frames: %s, videoCount: %s.", videoNotFoundCount, contextType, frameCount, presence?.videoCount ?? 0);
+        // Grace period: Wait for 2 consecutive failures before attempting context re-search, 3 before full navigation.
+        if (videoNotFoundCount < 2) {
+            emitStatusUpdate();
+            return;
+        }
+        // After 2+ failures, try re-searching frames to see if video moved to a different context.
+        if (videoNotFoundCount === 2) {
+            LOG.debug("recovery:context", "Re-searching frames for video element.");
+            try {
+                const newContext = await findVideoContext(currentPage, profile);
+                const validationState = await validateVideoElement(newContext, selectorType);
+                if (validationState.found) {
+                    LOG.info("Video found in different context after re-search. readyState=%s.", validationState.readyState);
+                    currentContext = newContext;
+                    videoNotFoundCount = 0;
+                    emitStatusUpdate();
+                    return;
+                }
+                LOG.warn("Re-search did not find video in any frame.");
+            }
+            catch (error) {
+                LOG.warn("Frame re-search failed: %s.", formatError(error));
+            }
+            emitStatusUpdate();
+            return;
+        }
+        // After 3+ consecutive failures, escalate to full page navigation recovery.
+        LOG.warn("Video element not found — recovering via %s.", RECOVERY_METHODS.pageNavigation);
+        // Check circuit breaker for too many failures.
+        const cbResult = checkCircuitBreaker(circuitBreaker, now);
+        if (cbResult.shouldTrip) {
+            LOG.error("Recovery failed after %s attempts — terminating stream.", cbResult.totalCount);
+            clearInterval(interval);
+            onCircuitBreak();
+            return;
+        }
+        // Set escalation to level 3 to trigger page navigation. We skip lower levels since they require a video element.
+        // Note: Keep state updates in sync with the main recovery path in executeRecoveryAction below.
+        recoveryState.escalationLevel = 3;
+        recoveryState.lastRecoveryTime = now;
+        recoveryState.totalAttempts++;
+        pendingReMinimize = true;
+        recoveryState.inProgress = true;
+        recordRecoveryAttempt(metrics, RECOVERY_METHODS.pageNavigation);
+        // Check page reload limit before attempting recovery.
+        if (!isPageReloadAllowed()) {
+            LOG.error("Page navigation rate limit reached (%s in %s minutes) — cannot recover without video element.", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
+            clearInterval(interval);
+            onCircuitBreak();
+            return;
+        }
+        const recoveryResult = await performPageNavigationRecovery();
+        // Page navigation disrupted the video stream. Mark a discontinuity regardless of navigation success so HLS clients resynchronize their decoders.
+        markStreamDiscontinuity();
+        // Set grace period to give page navigation time to take effect (L3 = 10 seconds).
+        recoveryState.graceUntil = now + recoveryGracePeriods[3];
+        if (recoveryResult.success && recoveryResult.newContext) {
+            currentContext = recoveryResult.newContext;
+            const duration = formatRecoveryDuration(metrics.currentRecoveryStartTime ?? now);
+            LOG.info("Recovered in %s via %s.", duration, RECOVERY_METHODS.pageNavigation);
+            recordRecoverySuccess(metrics, RECOVERY_METHODS.pageNavigation);
+            lastPageNavigationTime = Date.now();
+            resetRecoveryCounters();
+            resetEscalationState();
+            resetSegmentMonitoringState();
+            resetResolutionState();
+        }
+        else {
+            consecutiveNavigationFailures++;
+            LOG.warn("Page navigation did not restore playback.");
+        }
+        recoveryState.inProgress = false;
+        emitStatusUpdate();
+    }
+    /**
+     * Monitors segment production health. Performs two independent checks:
+     *
+     * 1. Post-recovery verification: After L2/L3 recovery completes and the grace period ends, verifies that segments are actually being produced. This catches the case
+     *    where recovery reports success but the MediaRecorder/FFmpeg pipeline has silently died.
+     *
+     * 2. Continuous size monitoring: Watches segment sizes on every tick to detect spontaneous capture pipeline death. Dead pipelines produce tiny segments (18 bytes
+     *    observed) while the video element appears healthy. Also detects segment staleness when no new segments have been produced for SEGMENT_STALENESS_TIMEOUT.
+     *
+     * @param now - Current timestamp for timing calculations.
+     * @param withinRecoveryGrace - Whether the monitor is within the post-recovery grace period.
+     * @returns True if the tick should exit (after tab replacement trigger), false to continue.
+     */
+    async function monitorSegmentHealth(now, withinRecoveryGrace) {
+        // Post-recovery segment verification. After recovery grace period ends, check that segments are flowing.
+        if ((segmentState.preRecoveryIndex !== null) && !withinRecoveryGrace) {
+            // Start the segment wait timer when recovery grace period ends.
+            segmentState.waitStartTime ??= now;
+            // Check if segments are flowing by comparing current index to pre-recovery index.
+            const entry = getStream(streamInfo.numericStreamId);
+            const currentIndex = entry?.segmenter?.getSegmentIndex() ?? null;
+            if ((currentIndex !== null) && (currentIndex > segmentState.preRecoveryIndex)) {
+                // Segments are flowing — recovery actually succeeded. Clear tracking state.
+                segmentState.preRecoveryIndex = null;
+                segmentState.waitStartTime = null;
+                segmentState.productionStalled = false;
+            }
+            else if ((now - segmentState.waitStartTime) > SEGMENT_STALL_TIMEOUT) {
+                // No new segments for SEGMENT_STALL_TIMEOUT after recovery grace period. The capture pipeline is dead.
+                LOG.warn("No segments produced for %ss after recovery — capture pipeline may have stalled.", SEGMENT_STALL_TIMEOUT / 1000);
+                segmentState.productionStalled = true;
+            }
+        }
+        // Continuous segment size monitoring. Runs on every healthy interval to detect spontaneous capture pipeline death.
+        const sizeCheckEntry = getStream(streamInfo.numericStreamId);
+        const currentSegmentIndex = sizeCheckEntry?.segmenter?.getSegmentIndex() ?? 0;
+        if ((currentSegmentIndex > segmentState.lastCheckedIndex) && sizeCheckEntry) {
+            // A new segment was produced. Update the staleness tracker and check its size.
+            segmentState.lastSegmentAdvanceTime = now;
+            const segmentSize = getLastSegmentSize(sizeCheckEntry) ?? 0;
+            if (segmentSize < TINY_SEGMENT_THRESHOLD) {
+                segmentState.consecutiveTinySegments++;
+                segmentState.wasInTinyState = true;
+                // Check track composition to determine the effective threshold. Dead capture pipelines produce audio-only segments (hasVideo=false) and always use the
+                // default count for fast detection. Segments with video trafs present use the provider-specific threshold, which may be higher for providers with extended
+                // static content (e.g., Xfinity commercial placeholders lasting several minutes).
+                const hasVideo = getLastSegmentHasVideo(sizeCheckEntry);
+                const effectiveThreshold = (hasVideo === false) ? TINY_SEGMENT_COUNT_TRIGGER : providerTinySegmentThreshold;
+                LOG.debug("recovery:tracks", "Below-threshold segment: %d bytes, hasVideo=%s, consecutive=%d, threshold=%d.", segmentSize, String(hasVideo), segmentState.consecutiveTinySegments, effectiveThreshold);
+                if (segmentState.consecutiveTinySegments >= effectiveThreshold) {
+                    LOG.warn("Detected %d consecutive undersized segments (%dKB) — capture pipeline may have stalled.", segmentState.consecutiveTinySegments, Math.round(segmentSize / 1024));
+                    // Trigger tab replacement if available, otherwise let circuit breaker handle it via segmentState.productionStalled.
+                    if (onTabReplacement && !recoveryState.inProgress) {
+                        await executeTabReplacement("tiny segments");
+                        return true;
+                    }
+                    else if (!onTabReplacement) {
+                        segmentState.productionStalled = true;
+                    }
+                }
+            }
+            else {
+                // Valid segment size. Check for spontaneous recovery from tiny segment state.
+                if (segmentState.wasInTinyState) {
+                    const hasVideo = getLastSegmentHasVideo(sizeCheckEntry);
+                    LOG.debug("recovery:segments", "Segment production self-healed (%d bytes, hasVideo=%s).", segmentSize, String(hasVideo));
+                }
+                segmentState.consecutiveTinySegments = 0;
+                segmentState.wasInTinyState = false;
+            }
+            segmentState.lastCheckedIndex = currentSegmentIndex;
+        }
+        else if (sizeCheckEntry && (segmentState.lastCheckedIndex > 0) && !withinRecoveryGrace &&
+            ((now - segmentState.lastSegmentAdvanceTime) > SEGMENT_STALENESS_TIMEOUT)) {
+            /* Segment staleness detection. The segment index has not advanced for longer than SEGMENT_STALENESS_TIMEOUT. This catches the case where Chrome's
+             * MediaRecorder silently stops emitting data — the input Readable stream stays "open" (no end/error events) but no data events fire. The segmenter
+             * receives nothing, produces no new segments, and the playlist freezes at the last known sequence number. The video element on the page continues
+             * playing normally (currentTime advances, no errors), so all video health checks pass. Without this check, the stale playlist persists indefinitely.
+             *
+             * The sizeCheckEntry guard prevents firing on a stream that was terminated mid-tick. The segmentState.lastCheckedIndex > 0 guard ensures we don't trigger
+             * during stream startup before the first segment has been produced. The recovery grace guard prevents false triggering during legitimate pauses (e.g.,
+             * after tab replacement while the new capture pipeline is initializing).
+             */
+            LOG.warn("No new segments produced for %ss — capture pipeline may have stalled.", SEGMENT_STALENESS_TIMEOUT / 1000);
+            if (onTabReplacement && !recoveryState.inProgress) {
+                await executeTabReplacement("segment staleness");
+                return true;
+            }
+            else if (!onTabReplacement) {
+                segmentState.productionStalled = true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Monitors video resolution against the configured viewport and triggers recovery for sustained ABR degradation. Uses a two-step escalation: page reload (forces ABR
+     * restart), then tab replacement (fresh page with new network connections). Accepts the resolution after both attempts to avoid infinite loops on legitimately
+     * low-resolution content. Also detects and logs resolution restoration after successful recovery.
+     *
+     * @param now - Current timestamp for timing calculations.
+     * @param state - Current video state with intrinsic resolution.
+     * @param isProgressing - Whether the video is advancing.
+     * @param withinRecoveryGrace - Whether the monitor is within the post-recovery grace period.
+     * @returns True if the tick should exit (after recovery action), false to continue.
+     */
+    async function monitorResolutionDegradation(now, state, isProgressing, withinRecoveryGrace) {
+        // Only check when playback is healthy, outside recovery grace, and the video has non-zero intrinsic dimensions.
+        if (!isProgressing || state.paused || state.error || state.ended || withinRecoveryGrace || (state.videoWidth === 0) || (state.videoHeight === 0)) {
+            return false;
+        }
+        const viewport = getEffectiveViewport(CONFIG);
+        const widthRatio = state.videoWidth / viewport.width;
+        const heightRatio = state.videoHeight / viewport.height;
+        const isDegraded = (widthRatio < RESOLUTION_RATIO_THRESHOLD) || (heightRatio < RESOLUTION_RATIO_THRESHOLD);
+        if (isDegraded && (now >= resolutionState.graceEnd)) {
+            resolutionState.consecutiveDegradedReadings++;
+            LOG.debug("recovery:resolution", "Video resolution: %s\u00d7%s (viewport: %s\u00d7%s, ratio: %s%%\u00d7%s%%, consecutive: %s/%s).", String(state.videoWidth), String(state.videoHeight), String(viewport.width), String(viewport.height), String(Math.round(widthRatio * 100)), String(Math.round(heightRatio * 100)), String(resolutionState.consecutiveDegradedReadings), String(RESOLUTION_DEGRADED_COUNT_THRESHOLD));
+        }
+        else {
+            resolutionState.consecutiveDegradedReadings = 0;
+        }
+        // Escalation step 1: page reload. Forces the provider's ABR to restart quality negotiation. Only triggers after sustained degradation
+        // (RESOLUTION_DEGRADED_COUNT_THRESHOLD consecutive readings) to let transient ABR dips self-heal.
+        if ((resolutionState.consecutiveDegradedReadings >= RESOLUTION_DEGRADED_COUNT_THRESHOLD) && (resolutionState.recoveryAttempt === 0)) {
+            const degradedDuration = resolutionState.consecutiveDegradedReadings * 2;
+            LOG.warn("Video resolution has been degraded for %ss (%s\u00d7%s in %s\u00d7%s viewport). Attempting recovery via %s.", String(degradedDuration), String(state.videoWidth), String(state.videoHeight), String(viewport.width), String(viewport.height), RECOVERY_METHODS.pageNavigation);
+            recoveryState.inProgress = true;
+            if (!isPageReloadAllowed()) {
+                LOG.warn("Resolution recovery deferred — page navigation rate limit reached (%s in %s minutes).", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
+                // Defer by pushing grace end forward to avoid re-triggering every 2 seconds.
+                resolutionState.graceEnd = now + RESOLUTION_GRACE_PERIOD;
+                recoveryState.inProgress = false;
+                emitStatusUpdate();
+                return true;
+            }
+            pendingReMinimize = true;
+            const recoveryResult = await performPageNavigationRecovery();
+            markStreamDiscontinuity();
+            resolutionState.consecutiveDegradedReadings = 0;
+            resolutionState.recoveryAttempt = 1;
+            resolutionState.graceEnd = now + RESOLUTION_GRACE_PERIOD;
+            if (recoveryResult.success && recoveryResult.newContext) {
+                currentContext = recoveryResult.newContext;
+                lastPageNavigationTime = Date.now();
+            }
+            else {
+                LOG.warn("Resolution recovery via page reload unsuccessful.");
+            }
+            recoveryState.inProgress = false;
+            emitStatusUpdate();
+            return true;
+        }
+        // Escalation step 2: tab replacement. Creates a fresh page with new capture pipeline and network connections.
+        if ((resolutionState.consecutiveDegradedReadings >= RESOLUTION_DEGRADED_COUNT_THRESHOLD) && (resolutionState.recoveryAttempt === 1)) {
+            if (onTabReplacement) {
+                const degradedDuration = resolutionState.consecutiveDegradedReadings * 2;
+                LOG.warn("Video resolution is still degraded after %ss (%s\u00d7%s). Attempting recovery via %s.", String(degradedDuration), String(state.videoWidth), String(state.videoHeight), RECOVERY_METHODS.tabReplacement);
+                await executeTabReplacement("resolution degraded");
+                resolutionState.consecutiveDegradedReadings = 0;
+                resolutionState.recoveryAttempt = 2;
+                resolutionState.graceEnd = now + RESOLUTION_GRACE_PERIOD;
+                return true;
+            }
+            // Tab replacement not available — skip directly to acceptance.
+            resolutionState.recoveryAttempt = 2;
+        }
+        // Acceptance: resolution still degraded after both recovery attempts. Log once and stop retrying.
+        if ((resolutionState.consecutiveDegradedReadings >= RESOLUTION_DEGRADED_COUNT_THRESHOLD) && (resolutionState.recoveryAttempt === 2)) {
+            LOG.warn("Video resolution remains degraded (%s\u00d7%s in %s\u00d7%s viewport) after recovery attempts. The stream will continue at reduced quality.", String(state.videoWidth), String(state.videoHeight), String(viewport.width), String(viewport.height));
+            resolutionState.recoveryAttempt = 3;
+        }
+        // Resolution is good: clear tracking state so future degradation starts fresh. Use "restored" when resolution matches the viewport, "improved" when it's
+        // above the degradation threshold but below the viewport. Include the recovery method so this single message tells the complete story.
+        if (!isDegraded && (resolutionState.recoveryAttempt > 0)) {
+            const isFullQuality = (state.videoWidth >= viewport.width) && (state.videoHeight >= viewport.height);
+            const verb = isFullQuality ? "restored" : "improved";
+            const method = (resolutionState.recoveryAttempt === 1) ? "page reload" : "tab replacement";
+            LOG.info("Video resolution %s to %s\u00d7%s after %s.", verb, String(state.videoWidth), String(state.videoHeight), method);
+            resolutionState.consecutiveDegradedReadings = 0;
+            resolutionState.recoveryAttempt = 0;
+            resolutionState.graceEnd = 0;
+        }
+        return false;
+    }
+    /**
+     * Handles proactive page reload for sites with maxContinuousPlayback limits. Some streaming sites enforce a maximum continuous playback duration (e.g., NBC.com cuts
+     * streams after 4 hours). This function proactively reloads the page before the site's limit expires to maintain uninterrupted streaming. The reload triggers
+     * PROACTIVE_RELOAD_MARGIN_MS (2 minutes) before the configured limit.
+     *
+     * Only runs when playback is healthy (escalationLevel === 0), not within a recovery grace period, and progressing normally.
+     *
+     * @param now - Current timestamp for timing calculations.
+     * @param state - Current video state.
+     * @param isProgressing - Whether the video is advancing.
+     * @param withinRecoveryGrace - Whether the monitor is within the post-recovery grace period.
+     * @returns True if the tick should exit (after reload attempt or deferral), false to continue.
+     */
+    async function handleProactiveReload(now, state, isProgressing, withinRecoveryGrace) {
+        if ((profile.maxContinuousPlayback === null) || (recoveryState.escalationLevel !== 0) || withinRecoveryGrace || !isProgressing || state.paused || state.error ||
+            state.ended) {
+            return false;
+        }
+        const maxPlaybackMs = profile.maxContinuousPlayback * 3600000;
+        const elapsedMs = now - lastPageNavigationTime;
+        if (elapsedMs < (maxPlaybackMs - PROACTIVE_RELOAD_MARGIN_MS)) {
+            return false;
+        }
+        const elapsedHours = (elapsedMs / 3600000).toFixed(1);
+        LOG.info("Proactive reload after %sh of continuous playback (site limit: %sh). Reloading page to prevent stream cutoff.", elapsedHours, String(profile.maxContinuousPlayback));
+        recoveryState.inProgress = true;
+        // Check page reload rate limit. Proactive reload is best-effort maintenance — if the reload budget is exhausted from recent error recoveries, we gracefully
+        // yield. If the site eventually cuts the stream, normal error recovery handles it.
+        if (!isPageReloadAllowed()) {
+            LOG.warn("Proactive reload deferred — page navigation rate limit reached (%s in %s minutes).", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
+            // Set a grace period to prevent this deferral from re-triggering every 2 seconds while the rate limit remains in effect. We set recoveryState.graceUntil
+            // directly rather than calling setRecoveryGracePeriod() because no recovery action was performed — the window state is unchanged and pendingReMinimize
+            // should not be set.
+            recoveryState.graceUntil = now + recoveryGracePeriods[3];
+            recoveryState.inProgress = false;
+            emitStatusUpdate();
+            return true;
+        }
+        const recoveryResult = await performPageNavigationRecovery();
+        markStreamDiscontinuity();
+        setRecoveryGracePeriod(3);
+        if (recoveryResult.success && recoveryResult.newContext) {
+            currentContext = recoveryResult.newContext;
+            lastPageNavigationTime = Date.now();
+            LOG.info("Proactive reload completed successfully.");
+            resetRecoveryCounters();
+            resetSegmentMonitoringState();
+            resetResolutionState();
+        }
+        else {
+            LOG.warn("Proactive reload unsuccessful. Will retry after recovery grace period.");
+        }
+        recoveryState.inProgress = false;
+        emitStatusUpdate();
+        return true;
+    }
+    /**
+     * Executes recovery when the monitor has determined that recovery is needed. Handles issue-aware escalation:
+     * - Paused issues try L1 (play/unmute) first since it works ~50% of the time for paused state
+     * - Buffering issues skip L1 and go directly to L2 (source reload) since L1 never helps buffering
+     * - If L2 has already been attempted, skip to L3 (page reload) since a second L2 always fails
+     *
+     * Also handles segment production stalls (direct escalation to tab replacement) and circuit breaker checks. Levels 1-2 use ensurePlayback() for in-page recovery,
+     * level 3 uses performPageNavigationRecovery() for full page navigation.
+     *
+     * @param now - Current timestamp for timing calculations.
+     * @param state - Current video state.
+     * @param isProgressing - Whether the video is advancing.
+     * @param isBuffering - Whether the video is actively buffering.
+     * @returns True if the tick should exit (circuit breaker tripped or tab replacement triggered), false to continue.
+     */
+    async function executeRecoveryAction(now, state, isProgressing, isBuffering) {
+        // Segment production stall handling. When segments stopped flowing after L2/L3 recovery, the capture pipeline is dead and normal recovery won't help. Skip the
+        // escalation ladder and go directly to tab replacement if available.
+        if (segmentState.productionStalled && onTabReplacement) {
+            LOG.warn("Capture pipeline still stalled — escalating to %s.", RECOVERY_METHODS.tabReplacement);
+            await executeTabReplacement("capture pipeline stalled");
+            return true;
+        }
+        // Check circuit breaker for too many failures.
+        const cbResult = checkCircuitBreaker(circuitBreaker, now);
+        if (cbResult.shouldTrip) {
+            const elapsedSeconds = circuitBreaker.firstFailureTime ? Math.round((now - circuitBreaker.firstFailureTime) / 1000) : 0;
+            LOG.error("Recovery failed after %s attempts in %ss — terminating stream.", cbResult.totalCount, elapsedSeconds);
+            clearInterval(interval);
+            onCircuitBreak();
+            return true;
+        }
+        // Issue-aware escalation. Determine the appropriate level based on the type of issue and whether source reload has already been attempted.
+        const issueCategory = getIssueCategory(state, !isProgressing, isBuffering);
+        let nextLevel;
+        if ((issueCategory === "paused") && (recoveryState.escalationLevel === 0)) {
+            // Paused issues: try L1 first (play/unmute works ~50% for paused).
+            nextLevel = 1;
+        }
+        else if (!recoveryState.sourceReloadAttempted) {
+            // First recovery attempt for buffering/other, or L1 didn't fix paused: try L2 (source reload).
+            nextLevel = 2;
+        }
+        else {
+            // Source reload already attempted: go to L3 (page reload).
+            nextLevel = 3;
+        }
+        // Note: Keep state updates in sync with the video-not-found recovery path in handleVideoNotFound above.
+        recoveryState.escalationLevel = nextLevel;
+        recoveryState.lastRecoveryTime = now;
+        recoveryState.totalAttempts++;
+        pendingReMinimize = true;
+        // Get recovery method name for logging and metrics.
+        const recoveryMethod = getRecoveryMethod(recoveryState.escalationLevel);
+        // Store issue type and time for UI display.
+        const issueType = formatIssueType(state, !isProgressing, isBuffering);
+        lastIssueType = issueType;
+        lastIssueTime = now;
+        // If a previous recovery was pending (L1 or L2 that didn't result in healthy playback), log that it was unsuccessful before starting the new attempt.
+        if (metrics.currentRecoveryMethod !== null) {
+            LOG.warn("%s did not resolve the issue — escalating to %s.", capitalize(metrics.currentRecoveryMethod), recoveryMethod);
+        }
+        else {
+            const issueDesc = getIssueDescription(issueCategory);
+            LOG.warn("Playback %s — recovering via %s.", issueDesc, recoveryMethod);
+        }
+        recordRecoveryAttempt(metrics, recoveryMethod);
+        // For L2/L3 recovery, record the current segment index so we can verify segments are flowing after recovery completes.
+        if (recoveryState.escalationLevel >= 2) {
+            const entry = getStream(streamInfo.numericStreamId);
+            segmentState.preRecoveryIndex = entry?.segmenter?.getSegmentIndex() ?? null;
+            segmentState.waitStartTime = null;
+            segmentState.productionStalled = false;
+        }
+        recoveryState.inProgress = true;
+        try {
+            // Levels 1-2: In-page recovery via ensurePlayback().
+            if (recoveryState.escalationLevel <= 2) {
+                await ensurePlayback(currentPage, currentContext, profile, { recoveryLevel: recoveryState.escalationLevel, skipNativeFullscreen: true });
+                if (recoveryState.escalationLevel === 2) {
+                    recoveryState.sourceReloadAttempted = true;
+                    markStreamDiscontinuity();
+                }
+                recoveryState.graceUntil = now + recoveryGracePeriods[recoveryState.escalationLevel];
+                resetResolutionState();
+            }
+            else {
+                // Level 3: Page navigation recovery.
+                // Safety check: If page navigation has failed twice consecutively, fall back to source reload.
+                if (consecutiveNavigationFailures >= 2) {
+                    LOG.warn("Page navigation has failed %s consecutive times — falling back to source reload.", consecutiveNavigationFailures);
+                    recoveryState.escalationLevel = 2;
+                    consecutiveNavigationFailures = 0;
+                    recoveryState.sourceReloadAttempted = false;
+                }
+                else {
+                    if (!isPageReloadAllowed()) {
+                        LOG.warn("Page navigation rate limit reached (%s in %s minutes) — falling back to source reload.", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
+                        recoveryState.escalationLevel = 2;
+                        recoveryState.sourceReloadAttempted = false;
+                    }
+                    else {
+                        const recoveryResult = await performPageNavigationRecovery();
+                        markStreamDiscontinuity();
+                        recoveryState.graceUntil = now + recoveryGracePeriods[3];
+                        if (recoveryResult.success && recoveryResult.newContext) {
+                            currentContext = recoveryResult.newContext;
+                            const duration = formatRecoveryDuration(metrics.currentRecoveryStartTime ?? now);
+                            LOG.info("Recovered in %s via %s.", duration, RECOVERY_METHODS.pageNavigation);
+                            recordRecoverySuccess(metrics, RECOVERY_METHODS.pageNavigation);
+                            lastPageNavigationTime = Date.now();
+                            resetRecoveryCounters();
+                            resetEscalationState();
+                            resetSegmentMonitoringState();
+                            resetResolutionState();
+                        }
+                        else {
+                            consecutiveNavigationFailures++;
+                            LOG.warn("Page navigation did not restore playback (attempt %s/2).", consecutiveNavigationFailures);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            LOG.warn("Recovery via %s failed: %s.", getRecoveryMethod(recoveryState.escalationLevel), formatError(error));
+        }
+        recoveryState.inProgress = false;
+        return false;
+    }
     /* Main monitoring interval. This runs every MONITOR_INTERVAL milliseconds to check video state and trigger recovery when needed.
      *
      * IMPORTANT: Early returns must call emitStatusUpdate() before returning (except when the stream is terminating, e.g., page closed or circuit breaker tripped). This
      * ensures SSE clients always have current status data (duration, memory, health) even during recovery, buffering, or video search periods. Without this, the
      * streamStatuses map becomes stale and new SSE connections receive outdated snapshots.
      *
-     * CHECK ORDER MATTERS: The recoveryInProgress check must come BEFORE the currentPage.isClosed() check. During tab replacement, the old page is intentionally closed
-     * while the handler creates a new page. If we check isClosed() first, we would terminate the interval while recovery is still in progress, causing status updates to
-     * stop permanently. The sequence is: (1) intervalCleared for explicit cleanup, (2) recoveryInProgress to continue during recovery, (3) isClosed() for unexpected
-     * page termination outside of recovery.
+     * CHECK ORDER MATTERS: The recoveryState.inProgress check must come BEFORE the currentPage.isClosed() check. During tab replacement, the old page is intentionally
+     * closed while the handler creates a new page. If we check isClosed() first, we would terminate the interval while recovery is still in progress, causing status
+     * updates to stop permanently. The sequence is: (1) intervalCleared for explicit cleanup, (2) recoveryState.inProgress to continue during recovery, (3) isClosed()
+     * for unexpected page termination outside of recovery.
      */
     const interval = setInterval(() => {
         // Stop monitoring if cleanup was requested.
@@ -409,7 +1167,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
         }
         // Skip health checks if a recovery operation is in progress. During tab replacement, the old page will be closed but we must keep the interval running until the
         // new page is assigned. Emit status so SSE clients see current state (health, duration, memory) even during recovery.
-        if (recoveryInProgress) {
+        if (recoveryState.inProgress) {
             emitStatusUpdate();
             return;
         }
@@ -423,6 +1181,13 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
             emitStatusUpdate();
             return;
         }
+        // For native streaming mode, monitor segment delivery health instead of video element state. We check the registry on each tick rather than caching the mode at
+        // startup because the streaming mode is set after the monitor starts (native streaming is attempted after setupStream returns).
+        const nativeEntry = getStream(streamInfo.numericStreamId);
+        if (nativeEntry?.streamingMode === "native") {
+            checkNativeStreamHealth(nativeEntry);
+            return;
+        }
         // Re-establish stream context for this interval tick. AsyncLocalStorage context is lost when entering setInterval callbacks.
         runWithStreamContext(streamContext, async () => {
             try {
@@ -476,121 +1241,9 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                     }
                     // If re-search failed, let the normal "video not found" logic handle it.
                 }
-                /* If no video element found, apply a grace period before triggering recovery. The video may be temporarily unavailable due to:
-                 * - readyState fluctuations (selectReadyVideo finds no video with readyState >= 3)
-                 * - Frame detachment/reattachment during page updates
-                 * - Momentary DOM changes during ad transitions
-                 *
-                 * We distinguish between "no video element exists" and "video exists but not ready". The latter is treated as buffering and given more time.
-                 */
+                // Video not found: apply grace period, attempt frame re-search, and escalate to page navigation recovery. Always exits the tick.
                 if (!state) {
-                    // Determine context type for diagnostic logging.
-                    const contextType = currentContext === currentPage ? "main page" : "iframe";
-                    const frameCount = currentPage.frames().length;
-                    // Check video presence to distinguish between "no video" and "video exists but not ready".
-                    let presence = null;
-                    try {
-                        presence = await checkVideoPresence(currentContext, selectorType);
-                    }
-                    catch (_error) {
-                        // If presence check fails (context destroyed), treat as no video.
-                    }
-                    if (presence?.anyVideoExists && !presence.readyVideoFound) {
-                        // Video element exists but doesn't meet readyState criteria. This is a buffering condition, not a missing video condition.
-                        // Apply the normal buffering grace period instead of escalating to navigation.
-                        LOG.debug("recovery", "Video is buffering (readyState=%s, elements=%s).", presence.maxReadyState, presence.videoCount);
-                        // Reset video not found counter since video actually exists.
-                        videoNotFoundCount = 0;
-                        // Emit status so SSE clients see current state even during this buffering condition.
-                        emitStatusUpdate();
-                        // Let the normal buffering detection handle this on subsequent checks.
-                        return;
-                    }
-                    videoNotFoundCount++;
-                    LOG.warn("Video element not found (attempt %s/3). Context: %s, frames: %s, videoCount: %s.", videoNotFoundCount, contextType, frameCount, presence?.videoCount ?? 0);
-                    // Grace period: Wait for 2 consecutive failures before attempting context re-search, 3 before full navigation.
-                    if (videoNotFoundCount < 2) {
-                        // First failure - just log and wait for next check. Emit status so SSE clients stay current.
-                        emitStatusUpdate();
-                        return;
-                    }
-                    // After 2+ failures, try re-searching frames to see if video moved to a different context.
-                    if (videoNotFoundCount === 2) {
-                        LOG.debug("recovery:context", "Re-searching frames for video element.");
-                        try {
-                            const newContext = await findVideoContext(currentPage, profile);
-                            const validationState = await validateVideoElement(newContext, selectorType);
-                            if (validationState.found) {
-                                LOG.info("Video found in different context after re-search. readyState=%s.", validationState.readyState);
-                                currentContext = newContext;
-                                videoNotFoundCount = 0;
-                                // Emit status so SSE clients see current state.
-                                emitStatusUpdate();
-                                return;
-                            }
-                            LOG.warn("Re-search did not find video in any frame.");
-                        }
-                        catch (error) {
-                            LOG.warn("Frame re-search failed: %s.", formatError(error));
-                        }
-                        // Emit status so SSE clients stay current during video search.
-                        emitStatusUpdate();
-                        return;
-                    }
-                    // After 3+ consecutive failures, escalate to full page navigation recovery.
-                    LOG.warn("Video element not found — recovering via %s.", RECOVERY_METHODS.pageNavigation);
-                    // Check circuit breaker for too many failures.
-                    const cbResult = checkCircuitBreaker(circuitBreaker, now);
-                    if (cbResult.shouldTrip) {
-                        LOG.error("Recovery failed after %s attempts — terminating stream.", cbResult.totalCount);
-                        clearInterval(interval);
-                        onCircuitBreak();
-                        return;
-                    }
-                    // Set escalation to level 3 to trigger page navigation. We skip lower levels since they require a video element.
-                    // Note: Keep state updates in sync with the main recovery path in the needsRecovery block below.
-                    escalationLevel = 3;
-                    lastRecoveryTime = now;
-                    totalRecoveryAttempts++;
-                    pendingReMinimize = true;
-                    recoveryInProgress = true;
-                    recordRecoveryAttempt(metrics, RECOVERY_METHODS.pageNavigation);
-                    // Check page reload limit before attempting recovery.
-                    const reloadWindow = now - CONFIG.playback.pageReloadWindow;
-                    pageReloadTimestamps = pageReloadTimestamps.filter((ts) => ts > reloadWindow);
-                    if (pageReloadTimestamps.length >= CONFIG.playback.maxPageReloads) {
-                        LOG.error("Page navigation rate limit reached (%s in %s minutes) — cannot recover without video element.", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
-                        clearInterval(interval);
-                        onCircuitBreak();
-                        return;
-                    }
-                    pageReloadTimestamps.push(now);
-                    // Use the unified recovery function with validation.
-                    const recoveryResult = await performPageNavigationRecovery();
-                    // Page navigation disrupted the video stream. Mark a discontinuity regardless of navigation success so HLS clients resynchronize their decoders.
-                    markStreamDiscontinuity();
-                    // Set grace period to give page navigation time to take effect (L3 = 10 seconds).
-                    recoveryGraceUntil = now + recoveryGracePeriods[3];
-                    if (recoveryResult.success && recoveryResult.newContext) {
-                        // Update the context reference for subsequent monitor checks (only after validation succeeds).
-                        currentContext = recoveryResult.newContext;
-                        // Log success with timing.
-                        const duration = formatRecoveryDuration(metrics.currentRecoveryStartTime ?? now);
-                        LOG.info("Recovered in %s via %s.", duration, RECOVERY_METHODS.pageNavigation);
-                        recordRecoverySuccess(metrics, RECOVERY_METHODS.pageNavigation);
-                        // Reset state after successful page navigation recovery.
-                        lastPageNavigationTime = Date.now();
-                        resetRecoveryCounters();
-                        resetEscalationState();
-                        resetSegmentMonitoringState();
-                    }
-                    else {
-                        consecutiveNavigationFailures++;
-                        LOG.warn("Page navigation did not restore playback.");
-                    }
-                    recoveryInProgress = false;
-                    // Emit status so SSE clients see the recovery result.
-                    emitStatusUpdate();
+                    await handleVideoNotFound(now);
                     return;
                 }
                 // Video was found - reset the not found counter, timeout counter, and save state for status reporting.
@@ -625,93 +1278,16 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                 // Check if we're within the buffering grace period (recently started buffering and haven't exceeded the threshold).
                 const withinBufferingGrace = isBuffering && bufferingStartTime && ((now - bufferingStartTime) < CONFIG.playback.bufferingGracePeriod);
                 // Check if we're within the recovery grace period (recently performed a recovery action and waiting for it to take effect).
-                const withinRecoveryGrace = now < recoveryGraceUntil;
-                /* Segment production monitoring. After L2/L3 recovery completes (grace period ends), we verify that segments are actually being produced. If recovery reported
-                 * success but the capture pipeline is dead (MediaRecorder stopped producing data, FFmpeg stdin idle), segments will stop flowing while the video element
-                 * appears healthy. This catches the 20+ minute freeze bug where PrismCast reports "Recovered" but Channels DVR receives no data.
-                 */
-                if ((preRecoverySegmentIndex !== null) && !withinRecoveryGrace) {
-                    // Start the segment wait timer when recovery grace period ends.
-                    segmentWaitStartTime ??= now;
-                    // Check if segments are flowing by comparing current index to pre-recovery index.
-                    const entry = getStream(streamInfo.numericStreamId);
-                    const currentSegmentIndex = entry?.segmenter?.getSegmentIndex() ?? null;
-                    if ((currentSegmentIndex !== null) && (currentSegmentIndex > preRecoverySegmentIndex)) {
-                        // Segments are flowing - recovery actually succeeded. Clear tracking state.
-                        preRecoverySegmentIndex = null;
-                        segmentWaitStartTime = null;
-                        segmentProductionStalled = false;
-                    }
-                    else if ((now - segmentWaitStartTime) > SEGMENT_STALL_TIMEOUT) {
-                        // No new segments for SEGMENT_STALL_TIMEOUT after recovery grace period. The capture pipeline is dead.
-                        LOG.warn("No segments produced for %ss after recovery — capture pipeline is not responding.", SEGMENT_STALL_TIMEOUT / 1000);
-                        segmentProductionStalled = true;
-                    }
-                }
-                /* Continuous segment size monitoring. Runs on every healthy interval to detect spontaneous capture pipeline death (no preceding recovery event). Dead pipelines
-                 * produce tiny segments (18 bytes observed) while the video element appears healthy. This catches failures that post-recovery index monitoring misses because
-                 * there's no recovery to trigger monitoring.
-                 */
-                const sizeCheckEntry = getStream(streamInfo.numericStreamId);
-                const currentSegmentIndex = sizeCheckEntry?.segmenter?.getSegmentIndex() ?? 0;
-                if ((currentSegmentIndex > lastCheckedSegmentIndex) && sizeCheckEntry) {
-                    // A new segment was produced. Update the staleness tracker and check its size.
-                    lastSegmentAdvanceTime = now;
-                    const segmentSize = getLastSegmentSize(sizeCheckEntry) ?? 0;
-                    if (segmentSize < TINY_SEGMENT_THRESHOLD) {
-                        consecutiveTinySegments++;
-                        wasInTinySegmentState = true;
-                        if (consecutiveTinySegments >= TINY_SEGMENT_COUNT_TRIGGER) {
-                            LOG.warn("Detected %d consecutive tiny segments (%d bytes) — capture pipeline is not responding.", consecutiveTinySegments, segmentSize);
-                            // Trigger tab replacement if available, otherwise let circuit breaker handle it via segmentProductionStalled. Return unconditionally after tab
-                            // replacement (matching stalled-capture and unresponsive-tab triggers) to avoid falling through the rest of the tick with stale pre-replacement state.
-                            if (onTabReplacement && !recoveryInProgress) {
-                                await executeTabReplacement("tiny segments");
-                                return;
-                            }
-                            else if (!onTabReplacement) {
-                                // No tab replacement callback - set stalled flag for circuit breaker.
-                                segmentProductionStalled = true;
-                            }
-                        }
-                    }
-                    else {
-                        // Valid segment size. Check for spontaneous recovery from tiny segment state. We don't mark discontinuity here - only tab replacement marks discontinuity.
-                        // Self-healing may be transient and not require decoder reset.
-                        if (wasInTinySegmentState) {
-                            LOG.debug("recovery:segments", "Segment production self-healed (%d bytes).", segmentSize);
-                        }
-                        // Reset tiny segment tracking.
-                        consecutiveTinySegments = 0;
-                        wasInTinySegmentState = false;
-                    }
-                    lastCheckedSegmentIndex = currentSegmentIndex;
-                }
-                else if (sizeCheckEntry && (lastCheckedSegmentIndex > 0) && !withinRecoveryGrace && ((now - lastSegmentAdvanceTime) > SEGMENT_STALENESS_TIMEOUT)) {
-                    /* Segment staleness detection. The segment index has not advanced for longer than SEGMENT_STALENESS_TIMEOUT. This catches the case where Chrome's
-                     * MediaRecorder silently stops emitting data — the input Readable stream stays "open" (no end/error events) but no data events fire. The segmenter
-                     * receives nothing, produces no new segments, and the playlist freezes at the last known sequence number. The video element on the page continues
-                     * playing normally (currentTime advances, no errors), so all video health checks pass. Without this check, the stale playlist persists indefinitely.
-                     *
-                     * The sizeCheckEntry guard prevents firing on a stream that was terminated mid-tick. The lastCheckedSegmentIndex > 0 guard ensures we don't trigger
-                     * during stream startup before the first segment has been produced. The recovery grace guard prevents false triggering during legitimate pauses (e.g.,
-                     * after tab replacement while the new capture pipeline is initializing).
-                     */
-                    LOG.warn("No new segments produced for %ss — capture pipeline may have stalled.", SEGMENT_STALENESS_TIMEOUT / 1000);
-                    if (onTabReplacement && !recoveryInProgress) {
-                        await executeTabReplacement("segment staleness");
-                        return;
-                    }
-                    else if (!onTabReplacement) {
-                        // No tab replacement callback - set stalled flag for circuit breaker.
-                        segmentProductionStalled = true;
-                    }
+                const withinRecoveryGrace = now < recoveryState.graceUntil;
+                // Segment production monitoring: post-recovery verification and continuous size/staleness checks.
+                if (await monitorSegmentHealth(now, withinRecoveryGrace)) {
+                    return;
                 }
                 /* Re-minimize check. After recovery, the browser window may have been un-minimized by fullscreen actions. As soon as the stream is healthy (progressing without
                  * issues), we re-minimize to reduce GPU usage.
                  */
                 if (pendingReMinimize && isProgressing && !state.paused && !state.error && !state.ended) {
-                    LOG.debug("recovery", "Re-minimizing browser window after successful recovery.");
+                    LOG.debug("recovery:general", "Re-minimizing browser window after successful recovery.");
                     pendingReMinimize = false;
                     await resizeAndMinimizeWindow(currentPage, true);
                 }
@@ -743,23 +1319,28 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                         fullscreenReapplyCount = 0;
                     }
                 }
-                /* Stall counter management. We increment stallCount when the video is not progressing and not within buffering grace. We reset to 0 when progression resumes.
-                 * This hysteresis prevents reacting to single-frame hiccups.
+                // Resolution degradation detection: two-step recovery (page reload, tab replacement) for sustained ABR degradation.
+                if (await monitorResolutionDegradation(now, state, isProgressing, withinRecoveryGrace)) {
+                    return;
+                }
+                /* Stall counter management. We increment recoveryState.stallCount when the video is not progressing and not within buffering grace. We reset to 0 when
+                 * progression resumes. This hysteresis prevents reacting to single-frame hiccups.
                  */
                 if (!isProgressing && !withinBufferingGrace) {
-                    stallCount++;
+                    recoveryState.stallCount++;
                 }
                 else if (isProgressing) {
-                    stallCount = 0;
+                    recoveryState.stallCount = 0;
                 }
-                /* Pause counter management. We increment pauseCount when video.paused is true and reset when it clears. This provides the same hysteresis as stall detection,
-                 * filtering out transient rebuffer pauses (where the player briefly pauses to refill its buffer) while still catching genuine persistent pauses.
+                /* Pause counter management. We increment recoveryState.pauseCount when video.paused is true and reset when it clears. This provides the same hysteresis as
+                 * stall detection, filtering out transient rebuffer pauses (where the player briefly pauses to refill its buffer) while still catching genuine persistent
+                 * pauses.
                  */
                 if (state.paused) {
-                    pauseCount++;
+                    recoveryState.pauseCount++;
                 }
                 else {
-                    pauseCount = 0;
+                    recoveryState.pauseCount = 0;
                 }
                 /* Recovery decision. We trigger recovery when any of these conditions are met AND we're not within the recovery grace period:
                  * - Video has an error state
@@ -769,9 +1350,9 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                  * - Segment production has stalled after recovery (capture pipeline dead)
                  */
                 const needsRecovery = !withinRecoveryGrace && (state.error || state.ended ||
-                    (state.paused && !withinBufferingGrace && (pauseCount > CONFIG.playback.stallCountThreshold)) ||
-                    (!isProgressing && !withinBufferingGrace && (stallCount > CONFIG.playback.stallCountThreshold)) ||
-                    segmentProductionStalled);
+                    (state.paused && !withinBufferingGrace && (recoveryState.pauseCount > CONFIG.playback.stallCountThreshold)) ||
+                    (!isProgressing && !withinBufferingGrace && (recoveryState.stallCount > CONFIG.playback.stallCountThreshold)) ||
+                    segmentState.productionStalled);
                 /* Escalation reset. After sustained healthy playback (SUSTAINED_PLAYBACK_REQUIRED, default 60 seconds), we reset the escalation level and circuit breaker.
                  * This allows a stream that recovered to start fresh, rather than immediately escalating to aggressive recovery on the next issue.
                  */
@@ -782,8 +1363,8 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                         LOG.info("Recovered in %s via %s.", duration, metrics.currentRecoveryMethod);
                         recordRecoverySuccess(metrics, metrics.currentRecoveryMethod);
                     }
-                    const healthyDuration = now - lastRecoveryTime;
-                    if ((escalationLevel > 0) && (healthyDuration > CONFIG.playback.sustainedPlaybackRequired)) {
+                    const healthyDuration = now - recoveryState.lastRecoveryTime;
+                    if ((recoveryState.escalationLevel > 0) && (healthyDuration > CONFIG.playback.sustainedPlaybackRequired)) {
                         // Clear buffering state. The bufferingStartTime may persist through recovery cycles due to networkState === 2 (NETWORK_LOADING) being true for live streams
                         // even during healthy playback. Since we have confirmed 60 seconds of progression, the stream is definitively not buffering.
                         bufferingStartTime = null;
@@ -793,208 +1374,15 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                         resetCircuitBreaker(circuitBreaker);
                     }
                 }
-                /* Proactive page reload. Some streaming sites enforce a maximum continuous playback duration (e.g., NBC.com cuts streams after 4 hours). When a domain
-                 * configures maxContinuousPlayback, we proactively reload the page before the site's limit expires to maintain uninterrupted streaming. The reload triggers
-                 * PROACTIVE_RELOAD_MARGIN_MS (2 minutes) before the configured limit, giving enough time for page navigation and video reinitialization.
-                 *
-                 * This check runs only when playback is healthy (escalationLevel === 0), not within a recovery grace period, and progressing normally. If recovery is already
-                 * in progress, the ongoing recovery will eventually perform a page navigation if needed. The page reload rate limit is also checked to avoid consuming reload
-                 * budget that error recovery needs. The timer resets after any successful full page navigation (proactive or recovery-triggered).
-                 */
-                if ((profile.maxContinuousPlayback !== null) && (escalationLevel === 0) && !withinRecoveryGrace && isProgressing && !state.paused && !state.error &&
-                    !state.ended) {
-                    const maxPlaybackMs = profile.maxContinuousPlayback * 3600000;
-                    const elapsedMs = now - lastPageNavigationTime;
-                    if (elapsedMs >= (maxPlaybackMs - PROACTIVE_RELOAD_MARGIN_MS)) {
-                        const elapsedHours = (elapsedMs / 3600000).toFixed(1);
-                        LOG.info("Proactive reload after %sh of continuous playback (site limit: %sh). Reloading page to prevent stream cutoff.", elapsedHours, String(profile.maxContinuousPlayback));
-                        recoveryInProgress = true;
-                        // Check page reload rate limit before attempting. Proactive reload is best-effort maintenance — if the reload budget is exhausted from recent error
-                        // recoveries, we gracefully yield. If the site eventually cuts the stream, normal error recovery handles it.
-                        const reloadWindow = now - CONFIG.playback.pageReloadWindow;
-                        pageReloadTimestamps = pageReloadTimestamps.filter((ts) => ts > reloadWindow);
-                        if (pageReloadTimestamps.length >= CONFIG.playback.maxPageReloads) {
-                            LOG.warn("Proactive reload deferred — page navigation rate limit reached (%s in %s minutes).", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
-                            // Set a grace period to prevent this deferral from re-triggering every 2 seconds while the rate limit remains in effect. The 10-second L3 grace
-                            // period spaces out re-checks, and the rate-limit window (default 15 minutes) will eventually expire old timestamps to allow the proactive reload. We
-                            // set recoveryGraceUntil directly rather than calling setRecoveryGracePeriod() because no recovery action was performed — the window state is unchanged
-                            // and pendingReMinimize should not be set.
-                            recoveryGraceUntil = now + recoveryGracePeriods[3];
-                            recoveryInProgress = false;
-                            emitStatusUpdate();
-                            return;
-                        }
-                        pageReloadTimestamps.push(now);
-                        const recoveryResult = await performPageNavigationRecovery();
-                        // Page navigation disrupted the video stream. Mark a discontinuity so HLS clients resynchronize their decoders.
-                        markStreamDiscontinuity();
-                        setRecoveryGracePeriod(3);
-                        if (recoveryResult.success && recoveryResult.newContext) {
-                            currentContext = recoveryResult.newContext;
-                            lastPageNavigationTime = Date.now();
-                            LOG.info("Proactive reload completed successfully.");
-                            resetRecoveryCounters();
-                            resetSegmentMonitoringState();
-                        }
-                        else {
-                            LOG.warn("Proactive reload unsuccessful. Will retry after recovery grace period.");
-                        }
-                        recoveryInProgress = false;
-                        emitStatusUpdate();
-                        return;
-                    }
+                // Proactive page reload for sites with maxContinuousPlayback limits.
+                if (await handleProactiveReload(now, state, isProgressing, withinRecoveryGrace)) {
+                    return;
                 }
-                /* Recovery execution. When recovery is needed, we update circuit breaker state, determine the appropriate recovery level based on issue type and history, and
-                 * execute the recovery action. The recovery system is issue-aware:
-                 * - Paused issues try L1 (play/unmute) first since it works ~50% of the time for paused state
-                 * - Buffering issues skip L1 and go directly to L2 (source reload) since L1 never helps buffering
-                 * - If L2 has already been attempted, skip to L3 (page reload) since a second L2 always fails
-                 */
+                // Recovery execution: issue-aware escalation (L1 play/unmute, L2 source reload, L3 page navigation) with circuit breaker.
                 if (needsRecovery) {
-                    /* Segment production stall handling. When we detect that segments stopped flowing after L2/L3 recovery, the capture pipeline is dead and normal recovery
-                     * won't help. We skip the escalation ladder and go directly to tab replacement if available.
-                     */
-                    if (segmentProductionStalled && onTabReplacement) {
-                        LOG.warn("Capture pipeline still stalled — escalating to %s.", RECOVERY_METHODS.tabReplacement);
-                        await executeTabReplacement("capture pipeline stalled");
-                        return;
-                    }
-                    // Check circuit breaker for too many failures. The helper handles incrementing, window checks, and resetting if outside the window.
-                    const cbResult = checkCircuitBreaker(circuitBreaker, now);
-                    if (cbResult.shouldTrip) {
-                        const elapsedSeconds = circuitBreaker.firstFailureTime ? Math.round((now - circuitBreaker.firstFailureTime) / 1000) : 0;
-                        LOG.error("Recovery failed after %s attempts in %ss — terminating stream.", cbResult.totalCount, elapsedSeconds);
-                        clearInterval(interval);
-                        onCircuitBreak();
+                    if (await executeRecoveryAction(now, state, isProgressing, isBuffering)) {
                         return;
                     }
-                    /* Issue-aware escalation. Instead of blindly incrementing the level, we determine the appropriate level based on:
-                   * 1. The type of issue (paused vs buffering vs other)
-                   * 2. Whether source reload (L2) has already been attempted in this page session
-                   * 3. The current escalation level
-                   *
-                   * Levels:
-                   * - Level 1: Basic play/unmute - only for paused issues
-                   * - Level 2: Reload video source - for buffering/other issues, or when L1 fails
-                   * - Level 3: Page navigation - when L2 fails or has already been attempted
-                   */
-                    const issueCategory = getIssueCategory(state, !isProgressing, isBuffering);
-                    let nextLevel;
-                    if ((issueCategory === "paused") && (escalationLevel === 0)) {
-                        // Paused issues: try L1 first (play/unmute works ~50% for paused).
-                        nextLevel = 1;
-                    }
-                    else if (!sourceReloadAttempted) {
-                        // First recovery attempt for buffering/other, or L1 didn't fix paused: try L2 (source reload).
-                        nextLevel = 2;
-                    }
-                    else {
-                        // Source reload already attempted: go to L3 (page reload).
-                        nextLevel = 3;
-                    }
-                    // Note: Keep state updates in sync with the video-not-found recovery path above.
-                    escalationLevel = nextLevel;
-                    lastRecoveryTime = now;
-                    totalRecoveryAttempts++;
-                    pendingReMinimize = true;
-                    // Get recovery method name for logging and metrics.
-                    const recoveryMethod = getRecoveryMethod(escalationLevel);
-                    // Store issue type and time for UI display.
-                    const issueType = formatIssueType(state, !isProgressing, isBuffering);
-                    lastIssueType = issueType;
-                    lastIssueTime = now;
-                    // If a previous recovery was pending (L1 or L2 that didn't result in healthy playback), log that it was unsuccessful before starting the new attempt.
-                    if (metrics.currentRecoveryMethod !== null) {
-                        LOG.warn("%s did not resolve the issue — escalating to %s.", capitalize(metrics.currentRecoveryMethod), recoveryMethod);
-                    }
-                    else {
-                        // First recovery attempt - log with issue description.
-                        const issueDesc = getIssueDescription(issueCategory);
-                        LOG.warn("Playback %s — recovering via %s.", issueDesc, recoveryMethod);
-                    }
-                    // Record this recovery attempt in metrics.
-                    recordRecoveryAttempt(metrics, recoveryMethod);
-                    // For L2/L3 recovery, record the current segment index so we can verify segments are flowing after recovery completes.
-                    if (escalationLevel >= 2) {
-                        const entry = getStream(streamInfo.numericStreamId);
-                        preRecoverySegmentIndex = entry?.segmenter?.getSegmentIndex() ?? null;
-                        segmentWaitStartTime = null; // Will be set after recovery grace period ends.
-                        segmentProductionStalled = false;
-                    }
-                    // Mark recovery in progress to prevent overlapping recovery attempts.
-                    recoveryInProgress = true;
-                    try {
-                        /* Levels 1-2: In-page recovery. These levels are handled by ensurePlayback() which performs recovery actions without navigating the page.
-                       */
-                        if (escalationLevel <= 2) {
-                            await ensurePlayback(currentPage, currentContext, profile, { recoveryLevel: escalationLevel, skipNativeFullscreen: true });
-                            // Track that source reload was attempted so we skip directly to L3 next time.
-                            if (escalationLevel === 2) {
-                                sourceReloadAttempted = true;
-                                // The source reload disrupted the video stream. Mark a discontinuity so HLS clients resynchronize their decoders.
-                                markStreamDiscontinuity();
-                            }
-                            // Set grace period to give this recovery level time to take effect before the next check.
-                            recoveryGraceUntil = now + recoveryGracePeriods[escalationLevel];
-                        }
-                        else {
-                            /* Level 3: Page navigation recovery. This is the most aggressive recovery - we navigate to the URL again and reinitialize everything.
-                           */
-                            // Safety check: If page navigation has failed twice consecutively, fall back to source reload. This prevents getting stuck in a loop when navigation
-                            // itself is broken (e.g., network issues, site blocking).
-                            if (consecutiveNavigationFailures >= 2) {
-                                LOG.warn("Page navigation has failed %s consecutive times — falling back to source reload.", consecutiveNavigationFailures);
-                                escalationLevel = 2;
-                                consecutiveNavigationFailures = 0;
-                                // Reset source reload tracking so the fallback L2 gets a fair chance. Without this, the next recovery cycle would skip L2 and try L3 again.
-                                sourceReloadAttempted = false;
-                            }
-                            else {
-                                // Check page reload limit to prevent excessive navigations. We allow MAX_PAGE_RELOADS within PAGE_RELOAD_WINDOW.
-                                const reloadWindow = now - CONFIG.playback.pageReloadWindow;
-                                // Prune old timestamps outside the window.
-                                pageReloadTimestamps = pageReloadTimestamps.filter((ts) => {
-                                    return ts > reloadWindow;
-                                });
-                                if (pageReloadTimestamps.length >= CONFIG.playback.maxPageReloads) {
-                                    LOG.warn("Page navigation rate limit reached (%s in %s minutes) — falling back to source reload.", CONFIG.playback.maxPageReloads, Math.round(CONFIG.playback.pageReloadWindow / 60000));
-                                    escalationLevel = 2;
-                                    // Reset source reload tracking so the fallback L2 gets a fair chance.
-                                    sourceReloadAttempted = false;
-                                }
-                                else {
-                                    pageReloadTimestamps.push(now);
-                                    // Use the unified recovery function with validation.
-                                    const recoveryResult = await performPageNavigationRecovery();
-                                    // Page navigation disrupted the video stream. Mark a discontinuity regardless of navigation success so HLS clients resynchronize their decoders.
-                                    markStreamDiscontinuity();
-                                    // Set grace period to give page navigation time to take effect (L3 = 10 seconds).
-                                    recoveryGraceUntil = now + recoveryGracePeriods[3];
-                                    if (recoveryResult.success && recoveryResult.newContext) {
-                                        // Update the context reference to the new context (only after validation succeeds).
-                                        currentContext = recoveryResult.newContext;
-                                        // Log success with timing.
-                                        const duration = formatRecoveryDuration(metrics.currentRecoveryStartTime ?? now);
-                                        LOG.info("Recovered in %s via %s.", duration, RECOVERY_METHODS.pageNavigation);
-                                        recordRecoverySuccess(metrics, RECOVERY_METHODS.pageNavigation);
-                                        // Reset state after successful page navigation recovery.
-                                        lastPageNavigationTime = Date.now();
-                                        resetRecoveryCounters();
-                                        resetEscalationState();
-                                        resetSegmentMonitoringState();
-                                    }
-                                    else {
-                                        consecutiveNavigationFailures++;
-                                        LOG.warn("Page navigation did not restore playback (attempt %s/2).", consecutiveNavigationFailures);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        LOG.warn("Recovery via %s failed: %s.", getRecoveryMethod(escalationLevel), formatError(error));
-                    }
-                    recoveryInProgress = false;
                 }
                 // Update lastTime for the next stall check.
                 lastTime = state.time;
@@ -1002,7 +1390,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                 emitStatusUpdate();
             }
             catch (error) {
-                recoveryInProgress = false;
+                recoveryState.inProgress = false;
                 // If the session or page was closed, stop monitoring gracefully.
                 if (isSessionClosedError(error) || currentPage.isClosed()) {
                     clearInterval(interval);
@@ -1028,7 +1416,7 @@ export function monitorPlaybackHealth(page, context, profile, url, streamId, str
                 // Log abort errors at debug level since they're expected during stream termination. Log other errors at error level.
                 const errorMessage = formatError(error);
                 if (errorMessage.includes("aborted")) {
-                    LOG.debug("recovery", "Monitor check aborted: %s.", errorMessage);
+                    LOG.debug("recovery:general", "Monitor check aborted: %s.", errorMessage);
                 }
                 else {
                     LOG.error("Monitor check failed: %s.", errorMessage);