prismcast 1.8.0 → 1.10.0

package/dist/browser/tuning/hulu.js

@@ -1,7 +1,7 @@
 import { LOG, delay, evaluateWithAbort, formatError } from "../../utils/index.js";
 import { logAvailableChannels, normalizeChannelName, scrollAndClick } from "./shared.js";
 import { CONFIG } from "../../config/index.js";
-// Unified channel cache for Hulu. Maps normalized channel names to their combined entry. Aliases (e.g., "abc" → same entry as "wls") share object references for
+// Unified channel cache for Hulu. Maps normalized channel names to their combined entry. Aliases (e.g., "abc" -> same entry as "wls") share object references for
 // automatic propagation of fresh programs and EAB data. Cleared on browser disconnect via clearHuluCache().
 const huluChannelCache = new Map();
 // Transient staging map for listing API response data. Maps channel UUIDs to their program schedules. Populated from listing API responses (which arrive before
@@ -48,7 +48,7 @@ function resolveHuluCacheKey(normalizedName) {
     return null;
 }
 /**
- * Looks up a channel in the unified cache by normalized name, with fuzzy fallback via resolveHuluCacheKey. Only used for lookups keyed by channelSelector —
+ * Looks up a channel in the unified cache by normalized name, with fuzzy fallback via resolveHuluCacheKey. Only used for lookups keyed by channelSelector -
  * internal cache operations that use API-derived names should use huluChannelCache.get() directly.
  * @param normalizedName - The normalized (lowercased, whitespace-collapsed) channel name to look up.
  * @returns The matching cache entry, or null if no match found.
@@ -152,11 +152,11 @@ async function readRenderedChannels(page) {
                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                     const text = srOnly.textContent ?? "";
                     const nameMatch = /^(.+?) Details, row/.exec(text);
-                    if (nameMatch) {
+                    if (nameMatch?.[1]) {
                         displayName = nameMatch[1].trim();
                     }
                     const rowMatch = /row (\d+) of/.exec(text);
-                    if (rowMatch) {
+                    if (rowMatch?.[1]) {
                         // Row numbers in sr-only text are 1-based. Convert to 0-based for scroll offset calculation.
                         rowNumber = parseInt(rowMatch[1], 10) - 1;
                     }
@@ -171,9 +171,8 @@ async function readRenderedChannels(page) {
     }
     // Assign DOM indices and populate the unified channel cache with row numbers and display names.
     const rendered = [];
-    for (let i = 0; i < channels.length; i++) {
-        const ch = channels[i];
-        rendered.push({ displayName: ch.displayName, domIndex: i, name: ch.name, rowNumber: ch.rowNumber });
+    for (const [domIndex, ch] of channels.entries()) {
+        rendered.push({ displayName: ch.displayName, domIndex, name: ch.name, rowNumber: ch.rowNumber });
         // Cache the row number and display name for future direct-scroll lookups.
         if (ch.rowNumber >= 0) {
             const existing = huluChannelCache.get(ch.name);
@@ -242,7 +241,7 @@ async function scrollToGuideRow(page, gridDocTop, rowHeight, rowIndex) {
 /**
  * Locates the on-now program cell for the channel at the given data-testid name (lowercased, trimmed), scrolls it into view, and returns its center coordinates
  * for a subsequent page.mouse.click(). We return coordinates rather than clicking inside the evaluate because page.mouse.click() generates the full pointer event
- * chain (pointerdown → mousedown → pointerup → mouseup → click) that React's event delegation requires, whereas a bare DOM .click() dispatches only a synthetic
+ * chain (pointerdown -> mousedown -> pointerup -> mouseup -> click) that React's event delegation requires, whereas a bare DOM .click() dispatches only a synthetic
  * click event that may not be processed reliably in a Puppeteer automation context.
  * @param page - The Puppeteer page object.
  * @param targetName - The lowercased, trimmed channel name to match against data-testid.
@@ -279,9 +278,9 @@ async function locateOnNowCell(page, targetName) {
 // pattern is used to identify call signs in the guide grid so position-based inference can find local affiliates that sort by their hidden network name.
 const CALL_SIGN_PATTERN = /^[WK][A-Z]{2,3}$/i;
 // Network names that map to local affiliate call signs in Hulu's guide. The details API returns channel_info.name as the local call sign rather than the
-// network name, so these names won't match any details response entry. Cold direct tuning is skipped for these — the guide grid handles them via
+// network name, so these names won't match any details response entry. Cold direct tuning is skipped for these - the guide grid handles them via
 // position-based inference. On the first guide grid tune, the in-page interceptor captures the affiliate's channel_id from the playlist request and caches
-// it under the channelSelector key (e.g., "abc" → uuid). Subsequent tunes resolve via warm direct tuning.
+// it under the channelSelector key (e.g., "abc" -> uuid). Subsequent tunes resolve via warm direct tuning.
 const NETWORK_NAMES_WITH_AFFILIATES = new Set(["abc", "cbs", "cw", "fox", "nbc", "pbs"]);
 /**
  * Position-based inference for local affiliates. When binary search returns "missing" (target name sorts between rendered channels but no exact match), this
@@ -312,30 +311,25 @@ function inferLocalAffiliate(rendered, targetName) {
         return null;
     }
     // Find the insertion point: the first anchor whose name sorts after the target.
-    let insertBeforeIndex = -1;
-    for (let i = 0; i < anchors.length; i++) {
-        if (targetName.localeCompare(anchors[i].name) < 0) {
-            insertBeforeIndex = i;
-            break;
-        }
-    }
-    // Determine the DOM index range between the two surrounding anchor channels.
+    const insertBeforeIndex = anchors.findIndex((anchor) => targetName.localeCompare(anchor.name) < 0);
+    // Determine the DOM index range between the two surrounding anchor channels. The anchor indexing is guaranteed in-range by construction of
+    // insertBeforeIndex above, but noUncheckedIndexedAccess needs explicit narrowing.
     let lowerDomIndex;
     let upperDomIndex;
     if (insertBeforeIndex === 0) {
         // Target sorts before all anchors. Look for call signs before the first anchor.
         lowerDomIndex = -1;
-        upperDomIndex = anchors[0].domIndex;
+        upperDomIndex = anchors[0]?.domIndex ?? rendered.length;
     }
     else if (insertBeforeIndex === -1) {
         // Target sorts after all anchors. Look for call signs after the last anchor.
-        lowerDomIndex = anchors[anchors.length - 1].domIndex;
+        lowerDomIndex = anchors.at(-1)?.domIndex ?? (rendered.length - 1);
         upperDomIndex = rendered.length;
     }
     else {
         // Target sorts between two anchors.
-        lowerDomIndex = anchors[insertBeforeIndex - 1].domIndex;
-        upperDomIndex = anchors[insertBeforeIndex].domIndex;
+        lowerDomIndex = anchors[insertBeforeIndex - 1]?.domIndex ?? -1;
+        upperDomIndex = anchors[insertBeforeIndex]?.domIndex ?? rendered.length;
     }
     // Find call sign channels in the DOM range between the two anchors.
     for (const ch of rendered) {
@@ -388,8 +382,8 @@ async function waitForPlayButton(page, playSelector, timeout) {
 }
 /**
  * Clicks the on-now program cell and waits for the play button, retrying on failure. Handles two distinct failure modes: (1) the on-now cell click doesn't
- * register because React hasn't fully hydrated event handlers — the play button never appears; (2) the play button appears and is clicked but the click is
- * silently swallowed — playback doesn't start. Both failures are detected by waitForPlayButton and trigger a retry of the full on-now cell and play button
+ * register because React hasn't fully hydrated event handlers - the play button never appears; (2) the play button appears and is clicked but the click is
+ * silently swallowed - playback doesn't start. Both failures are detected by waitForPlayButton and trigger a retry of the full on-now cell and play button
  * sequence after a brief delay.
  * @param page - The Puppeteer page object.
  * @param clickTarget - The lowercased, trimmed channel name to locate in the guide grid.
@@ -400,7 +394,7 @@ async function waitForPlayButton(page, playSelector, timeout) {
 async function clickOnNowCellAndPlay(page, clickTarget, playSelector, channelName) {
     // Maximum number of on-now cell click attempts. The first click may not register if React hasn't finished hydrating the guide's event handlers.
     const MAX_CLICK_ATTEMPTS = 3;
-    // Shorter timeout for the play button on non-final attempts. When a click registers, the play button appears in under 10ms — this timeout only determines how
+    // Shorter timeout for the play button on non-final attempts. When a click registers, the play button appears in under 10ms - this timeout only determines how
     // quickly we detect a missed click and retry. Keeping it low saves ~2s per failed attempt compared to the previous 3000ms value.
     const RETRY_PLAY_TIMEOUT = 1000;
     // Delay between click retries. Gives React additional time to finish hydrating event handlers.
@@ -483,7 +477,7 @@ async function clickOnNowCellAndPlay(page, clickTarget, playSelector, channelNam
  * self-resolved from in-page API data. Two resolution mechanisms handle different channel types:
  *
  * 1. Server-side injection: finds the currently-airing EAB from the entry's program schedule and calls __prismcastResolveDirectTune to inject both values into the
- *    held playlist request. Primary mechanism for local affiliates whose call signs don't match the channelSelector network name — the interceptor can't
+ *    held playlist request. Primary mechanism for local affiliates whose call signs don't match the channelSelector network name - the interceptor can't
  *    self-resolve by name for these, so external injection is the only path.
  * 2. Self-resolution detection: queries __prismcastIsDirectTuneResolved to check if the interceptor already captured UUID+EAB from the expanded
  *    Details+Listing API responses and resolved the playlist autonomously. Primary mechanism for non-affiliate channels on cold cache, where the interceptor's
@@ -504,7 +498,7 @@ async function tryFastPathTune(page, entry, channelName) {
         const currentEab = findCurrentEabFromPrograms(entry.programs);
         if (currentEab) {
             const injected = await page.evaluate((u, e) => {
-                const resolver = window.__prismcastResolveDirectTune;
+                const resolver = window["__prismcastResolveDirectTune"];
                 if (typeof resolver === "function") {
                     return resolver(u, e);
                 }
@@ -521,7 +515,7 @@ async function tryFastPathTune(page, entry, channelName) {
     // responses triggered by the Channels tab click and resolves the held playlist autonomously, making the guide grid click redundant.
     if (!resolved) {
         const selfResolved = await page.evaluate(() => {
-            const checker = window.__prismcastIsDirectTuneResolved;
+            const checker = window["__prismcastIsDirectTuneResolved"];
             if (typeof checker === "function") {
                 return checker();
             }
@@ -554,7 +548,7 @@ async function tryFastPathTune(page, entry, channelName) {
  */
 async function releaseHeldPlaylist(page) {
     await page.evaluate(() => {
-        const release = window.__prismcastReleasePlaylist;
+        const release = window["__prismcastReleasePlaylist"];
         if (typeof release === "function") {
             release();
         }
@@ -563,13 +557,13 @@ async function releaseHeldPlaylist(page) {
 /**
  * Guide grid strategy: finds a channel in a virtualized, alphabetically sorted channel grid by scrolling the page to the target row using binary search, then
  * clicking the on-now program cell to open the playback overlay. This strategy works for sites like Hulu Live TV where the channel guide is rendered as a
- * virtualized list — only ~13 of ~124 rows exist in the DOM at any time, positioned absolutely within a tall spacer div. The virtualizer renders rows based on
+ * virtualized list - only ~13 of ~124 rows exist in the DOM at any time, positioned absolutely within a tall spacer div. The virtualizer renders rows based on
  * the page scroll position (`document.documentElement.scrollTop`), so we scroll to bring the target channel into the DOM, then interact with it directly.
  *
  * Three mechanisms handle different channel types:
- * 1. Binary search with passive row number caching — primary mechanism for most channels (~800ms first time, ~200ms on cache hit)
- * 2. Position-based inference — handles local affiliates when searching by network name (e.g., "ABC" finds the local call sign at the right sort position)
- * 3. Linear scan fallback — safety net for raw call sign searches or any channel the binary search cannot find (~2.4 seconds)
+ * 1. Binary search with passive row number caching - primary mechanism for most channels (~800ms first time, ~200ms on cache hit)
+ * 2. Position-based inference - handles local affiliates when searching by network name (e.g., "ABC" finds the local call sign at the right sort position)
+ * 3. Linear scan fallback - safety net for raw call sign searches or any channel the binary search cannot find (~2.4 seconds)
  *
  * The selection process:
  * 1. If listSelector is provided, click the tab/button to reveal the channel list (e.g., a "Channels" tab)
@@ -587,7 +581,7 @@ async function guideGridStrategy(page, profile) {
     const { channelSelection, channelSelector: channelName } = profile;
     const { listSelector, playSelector } = channelSelection;
     // Ensure the guide is open and on the correct tab. We wait for the tab button to become VISIBLE (not just present in the DOM) because the guide overlay may exist
-    // in the DOM structure while still hidden during page initialization or animation. Clicking a hidden button dispatches a DOM event but has no visual effect — the
+    // in the DOM structure while still hidden during page initialization or animation. Clicking a hidden button dispatches a DOM event but has no visual effect - the
     // guide remains hidden and the virtualizer never populates rows. We use $eval for the click because overlapping elements (spinners, overlays) can intercept
     // Puppeteer's coordinate-based mouse events.
     if (listSelector) {
@@ -601,7 +595,7 @@ async function guideGridStrategy(page, profile) {
             LOG.warn("Could not click channel list selector %s: %s.", listSelector, formatError(error));
         }
     }
-    // Wait for channel grid rows to become visible. If rows don't appear within a short initial window, retry the tab click once — the first click may have fired
+    // Wait for channel grid rows to become visible. If rows don't appear within a short initial window, retry the tab click once - the first click may have fired
     // during a transitional state before the guide was fully interactive, or the guide may have been animating open.
     let rowsVisible = false;
     for (let guideAttempt = 0; guideAttempt < 2; guideAttempt++) {
@@ -685,7 +679,7 @@ async function guideGridStrategy(page, profile) {
             break;
         }
         // Determine binary search direction by comparing the target against the first and last rendered non-call-sign channel names. Call sign channels (W*/K*
-        // local affiliates) are excluded from direction comparison because they sort by hidden network name, not by their displayed call sign — using them for
+        // local affiliates) are excluded from direction comparison because they sort by hidden network name, not by their displayed call sign - using them for
         // localeCompare would send the search the wrong way.
         const nonCallSigns = rendered.filter((ch) => !CALL_SIGN_PATTERN.test(ch.name));
         if (nonCallSigns.length === 0) {
@@ -693,8 +687,8 @@ async function guideGridStrategy(page, profile) {
             low = mid + 1;
             continue;
         }
-        const first = nonCallSigns[0].name;
-        const last = nonCallSigns[nonCallSigns.length - 1].name;
+        const first = nonCallSigns[0]?.name ?? "";
+        const last = nonCallSigns.at(-1)?.name ?? "";
         if (normalizedName.localeCompare(first) < 0) {
             // Target sorts before the first visible non-call-sign channel. Scroll up (toward lower row indices).
             high = mid - 1;
@@ -705,7 +699,7 @@ async function guideGridStrategy(page, profile) {
             low = mid + 1;
             continue;
         }
-        // The target is alphabetically between the first and last rendered channels but was not found by exact data-testid match. This is the "missing" case — the
+        // The target is alphabetically between the first and last rendered channels but was not found by exact data-testid match. This is the "missing" case - the
         // channel may be a local affiliate whose call sign doesn't match the network name we're searching for. Try position-based inference.
         const inferred = inferLocalAffiliate(rendered, normalizedName);
         if (inferred) {
@@ -751,7 +745,7 @@ async function guideGridStrategy(page, profile) {
     if (!found) {
         // Log available channels from the unified cache to help users identify the correct channelSelector value. The cache accumulates all channel names
         // encountered during binary search and linear scan, so it contains most or all channels even though the virtualized grid only renders ~13 at a time.
-        const availableChannels = Array.from(huluChannelCache.keys()).sort();
+        const availableChannels = Array.from(huluChannelCache.keys()).toSorted();
         if (availableChannels.length > 0) {
             logAvailableChannels({
                 availableChannels,
@@ -767,12 +761,12 @@ async function guideGridStrategy(page, profile) {
     // triggers full Details+Listing API responses. For non-affiliates, the in-page interceptor may have already self-resolved from those responses (capturing
     // UUID+EAB and swapping the playlist autonomously). For channels where the interceptor hasn't self-resolved, the unified cache provides UUID+EAB for
     // injection. Either path avoids the redundant on-now cell click. Note: for affiliates, the inference block above may have already called tryFastPathTune with
-    // the same entry — that call is redundant here but harmless (~10ms), and avoiding it with a flag would create a fragile coupling to the inference block.
+    // the same entry - that call is redundant here but harmless (~10ms), and avoiding it with a flag would create a fragile coupling to the inference block.
     const fastPathSuccess = await tryFastPathTune(page, findHuluChannelEntry(normalizedName), channelName);
     if (fastPathSuccess) {
         return { success: true };
     }
-    // Release the held playlist before falling through to the click path. Neither tryFastPathTune nor the inference block calls releaseHeldPlaylist — they either
+    // Release the held playlist before falling through to the click path. Neither tryFastPathTune nor the inference block calls releaseHeldPlaylist - they either
     // inject successfully (resolving the held playlist directly) or return false without side effects. The release is a no-op if the hold was already resolved.
     await releaseHeldPlaylist(page);
     // Click the on-now program cell and wait for the play button, with click retries to handle React hydration timing.
@@ -804,7 +798,7 @@ async function guideGridWithRetry(page, profile) {
 /**
  * Sets up server-side response interception on the page to capture channel data from Hulu's guide APIs. As the live page loads, Hulu fetches program details from
  * guide.hulu.com/guide/details in batches and program schedules from guide.hulu.com/guide/listing. We intercept both responses to populate the unified channel
- * cache: listing data goes into the staging map (UUID → programs), then details data triggers populateHuluChannelCache which joins name → UUID with staged
+ * cache: listing data goes into the staging map (UUID -> programs), then details data triggers populateHuluChannelCache which joins name -> UUID with staged
  * programs. Also bridges in-page console signals (HULU-DIAG, HULU-CACHE, HULU-FAIL) to the Node.js LOG. Uses a WeakSet to prevent duplicate listener
  * registration.
  * @param page - The Puppeteer page object.
@@ -848,7 +842,7 @@ function setupDetailsResponseInterception(page) {
         }
         // Direct tune failure: the interceptor's hold period expired without resolving UUID+EAB for the target channel. The 503 response prevents Hulu from playing
         // the wrong channel. The guide grid binary search runs as the fallback. Since all cold tunes go through the guide grid (triggering full API expansion), this
-        // path should rarely be reached — it provides defense-in-depth against silent false positives.
+        // path should rarely be reached - it provides defense-in-depth against silent false positives.
         if (text.startsWith("[HULU-FAIL]")) {
             LOG.warn(text);
         }
@@ -858,7 +852,7 @@ function setupDetailsResponseInterception(page) {
         if (response.status() !== 200) {
             return;
         }
-        // Details API: populate the unified channel cache by joining name → UUID from this response with programs from the listing staging map.
+        // Details API: populate the unified channel cache by joining name -> UUID from this response with programs from the listing staging map.
         if (url.includes("guide.hulu.com/guide/details")) {
             void response.json().then((data) => {
                 if (!Array.isArray(data.items)) {
@@ -904,7 +898,7 @@ function setupDetailsResponseInterception(page) {
 /**
  * Resolves a direct URL for Hulu channel tuning and installs a fetch interceptor that handles both warm and cold tunes. On warm cache (UUID and EAB known from
  * previous API responses), the interceptor has both values at install time and swaps the first playlist request immediately. On cold cache (no UUID), returns
- * null so the guide grid runs — the Channels tab click triggers full Details+Listing API expansion for all ~123 channels, and the interceptor captures UUID+EAB
+ * null so the guide grid runs - the Channels tab click triggers full Details+Listing API expansion for all ~123 channels, and the interceptor captures UUID+EAB
  * from those expanded responses to resolve the held playlist. Without the Channels tab click, the initial page load only provides data for ~10 visible channels.
  * On all tunes, the interceptor also expands listing and details API requests to populate the full cache for future warm tunes.
  * @param channelSelector - The channel selector string (e.g., "Fox", "CNN", "ESPN").
@@ -919,7 +913,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
     // during both the guide grid flow (cold cache) and the intercepted page load (warm cache).
     setupDetailsResponseInterception(page);
     // Look up the currently-airing EAB for the target channel (if UUID and programs are known). On warm cache (both UUID and EAB available), the interceptor has
-    // both at install time and swaps immediately. On cold cache (no UUID), we return null below so the guide grid runs — the Channels tab click triggers full API
+    // both at install time and swaps immediately. On cold cache (no UUID), we return null below so the guide grid runs - the Channels tab click triggers full API
     // expansion.
     const cachedEab = (cachedEntry?.programs) ? findCurrentEabFromPrograms(cachedEntry.programs) : null;
     const isWarmCache = Boolean(cachedUuid && cachedEab);
@@ -927,7 +921,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
         LOG.debug("tuning:hulu", "resolveHuluDirectUrl: warm cache for %s (uuid=%s, eab=%s).", channelSelector, cachedUuid, cachedEab);
     }
     else if (!cachedUuid) {
-        // On cold cache, all channels fall through to the guide grid — the Channels tab click triggers full Details+Listing API expansion for all ~123 channels.
+        // On cold cache, all channels fall through to the guide grid - the Channels tab click triggers full Details+Listing API expansion for all ~123 channels.
         // The affiliate/non-affiliate distinction is diagnostic only (both return null). Affiliates use position-based inference; non-affiliates use exact match.
         if (NETWORK_NAMES_WITH_AFFILIATES.has(normalizedName)) {
             LOG.debug("tuning:hulu", "resolveHuluDirectUrl: cold cache for %s (local affiliate). Falling through to guide grid.", channelSelector);
@@ -960,7 +954,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
     /* Install the fetch interceptor before navigation on both warm and cold tunes. On warm tunes, it swaps channel_id and content_eab_id in playlist requests
      * immediately. On cold tunes, the guide grid's Channels tab click triggers full API expansion, and the interceptor holds the playlist request until both
      * UUID and EAB are captured from those responses. On all tunes, it captures listing API responses to build an in-page EAB map and expands subsequent
-     * details API requests, populating the UUID cache to ~123 channels on a single page load. The script runs via evaluateOnNewDocument — it executes before
+     * details API requests, populating the UUID cache to ~123 channels on a single page load. The script runs via evaluateOnNewDocument - it executes before
      * any page JavaScript, patching window.fetch so Hulu's module-scoped fetch reference captures the interceptor. Each stream gets its own page via
      * createPageWithCapture(), so there's no persistence concern.
      */
@@ -969,7 +963,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
         // inject UUID+EAB via the fast path (resolving the held playlist) or release the hold before falling through to the click path.
         const attemptDirectTune = true;
         await page.evaluateOnNewDocument((initialUuid, initialEab, cachedUuids, cachedEabs, targetName, holdPlaylist) => {
-            // evaluateOnNewDocument runs in every frame, including ad iframes. We only want to intercept fetches in the main frame — iframes don't make Hulu API
+            // evaluateOnNewDocument runs in every frame, including ad iframes. We only want to intercept fetches in the main frame - iframes don't make Hulu API
             // calls. The try/catch handles cross-origin iframes where accessing window.top throws a SecurityError.
             try {
                 if (window.self !== window.top) {
@@ -991,24 +985,32 @@ async function resolveHuluDirectUrl(channelSelector, page) {
             // the click-based flow where the playlist should pass through immediately and capture the affiliate UUID via [HULU-CACHE].
             let holdActive = holdPlaylist;
             // Tracks whether the initial page-load playlist request has been seen. When holdActive is false (cold affiliate guide grid click fallback), the first live
-            // playlist request carries the previously-playing channel's UUID — not the target's. We skip that one and only capture from subsequent requests, which
+            // playlist request carries the previously-playing channel's UUID - not the target's. We skip that one and only capture from subsequent requests, which
             // are triggered by the guide grid's play button click and carry the correct affiliate UUID.
             let initialPlaylistSeen = false;
             // eslint-disable-next-line no-console
             console.log("[HULU-DIAG] Fetch interceptor installed (" + ((uuid && eab) ? "warm" : "cold") + ")." + (uuid ? " uuid=" + uuid + " eab=" + (eab || "pending") : ""));
             // Promise that resolves when both UUID and EAB are available for the playlist swap. On warm cache, resolves immediately (both injected at install time).
             // On cold cache, resolves when the in-page listing and details API response parsers have captured both values. The playlist handler awaits this Promise
-            // to hold the request until the target channel's data is ready.
+            // to hold the request until the target channel's data is ready. We use Promise.withResolvers() (Chrome 119+) for the deferred case so the resolver-extraction
+            // pattern matches inPageTimeout below rather than the older "new Promise(executor) + outer-scope variable" pattern.
             let directTuneResolve = null;
-            const directTunePromise = (uuid && eab) ?
-                Promise.resolve() :
-                new Promise((resolve) => { directTuneResolve = resolve; });
+            let directTunePromise;
+            if (uuid && eab) {
+                directTunePromise = Promise.resolve();
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Standard pattern for signal promises.
+                const deferred = Promise.withResolvers();
+                directTunePromise = deferred.promise;
+                directTuneResolve = deferred.resolve;
+            }
             // Tracks whether the direct tune has been successfully resolved (UUID+EAB available and playlist swap in progress). Set by tryResolveDirectTune when both
             // values are captured from API responses or injected externally. Warm cache starts resolved. Used by __prismcastIsDirectTuneResolved to let the guide grid
             // strategy detect that the interceptor already handled the tune autonomously, avoiding a redundant on-now cell click.
             let directTuneResolved = Boolean(uuid && eab);
             // Checks whether both UUID and EAB are now known and resolves directTunePromise if so. Called after each successful capture from listing or details API
-            // responses. Order-independent — handles both "listing first, details second" and "details first, listing second" sequences.
+            // responses. Order-independent - handles both "listing first, details second" and "details first, listing second" sequences.
             function tryResolveDirectTune() {
                 if (uuid && eab && directTuneResolve) {
                     directTuneResolved = true;
@@ -1016,11 +1018,19 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                     directTuneResolve = null;
                 }
             }
+            // Returns a Promise that resolves after the given delay. Used as the timeout side of Promise.race against a deferred Promise. Defined in-page because
+            // node:timers/promises is not reachable from browser context, but Promise.withResolvers (Chrome 119+) is.
+            async function inPageTimeout(ms) {
+                // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Standard pattern for signal promises.
+                const { promise, resolve } = Promise.withResolvers();
+                setTimeout(resolve, ms);
+                return promise;
+            }
             // Injection endpoint for the guide grid strategy's fast-path tune. After binary search identifies the target channel and the unified cache provides the
             // UUID and EAB, the strategy calls this function via page.evaluate to feed both values into the interceptor. The held playlist request then resumes with the
             // swapped channel_id and content_eab_id. Returns true if the injection was accepted (directTunePromise not yet resolved), false if the Promise already
             // resolved (self-resolution from API data, 8s timeout, or a previous injection).
-            window.__prismcastResolveDirectTune = (u, e) => {
+            window["__prismcastResolveDirectTune"] = (u, e) => {
                 if (!directTuneResolve) {
                     return false;
                 }
@@ -1032,7 +1042,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
             // Release endpoint for the guide grid strategy's click-path fallback. When the fast-path injection can't proceed (UUID or EAB not in unified cache),
             // the strategy calls this to unblock the held playlist request and revert to the click-based flow. Sets holdActive to false so the playlist handler follows
             // the affiliate capture path ([HULU-CACHE]) on subsequent requests from the play button click.
-            window.__prismcastReleasePlaylist = () => {
+            window["__prismcastReleasePlaylist"] = () => {
                 holdActive = false;
                 if (directTuneResolve) {
                     directTuneResolve();
@@ -1040,39 +1050,38 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                 }
             };
             // Query endpoint for the guide grid strategy to check if the interceptor has already resolved the direct tune. Returns true if the playlist was swapped
-            // (self-resolution from API data, external injection, or warm cache). The guide grid checks this after finding the target channel — if the interceptor
+            // (self-resolution from API data, external injection, or warm cache). The guide grid checks this after finding the target channel - if the interceptor
             // already handled the tune, the on-now cell click is redundant and can be skipped.
-            window.__prismcastIsDirectTuneResolved = () => directTuneResolved;
+            window["__prismcastIsDirectTuneResolved"] = () => directTuneResolved;
             // In-page EAB map built dynamically from listing API responses. On the first cold tune, cachedEabs is empty (no pre-computed data from Node.js), so this
             // map is the sole source of expansion data for details API requests. Populated asynchronously when the first listing response arrives.
             const capturedCurrentEabs = new Map();
             // Deferred Promise that resolves when captureListingData finishes parsing the first listing response. Details API requests await this Promise (with a 2s
             // timeout) before expanding, so even the very first details request gets expanded with listing-derived EABs. The listing response typically arrives
-            // ~200-600ms after the request fires, adding minimal latency to the details response — and the details API is not on the critical path for the channel
+            // ~200-600ms after the request fires, adding minimal latency to the details response - and the details API is not on the critical path for the channel
             // grid that binary search needs (it only provides program info for the mini-guide overlay).
-            let listingCapturedResolve = null;
-            const listingCapturedPromise = new Promise((resolve) => {
-                listingCapturedResolve = resolve;
-            });
+            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Standard pattern for signal promises.
+            const { promise: listingCapturedPromise, resolve: signalListingCaptured } = Promise.withResolvers();
+            let listingCaptureSignaled = false;
             // Fire-and-forget: parses a listing API response to build the in-page EAB map. For each channel, finds the currently-airing program by comparing airing
             // times against the current time, mirroring the server-side findCurrentEabFromPrograms() logic. Called on all listing return paths (expanded and passthrough).
             function captureListingData(response) {
                 try {
                     void response.clone().json().then((data) => {
-                        const channels = data.channels;
+                        const channels = data["channels"];
                         if (!Array.isArray(channels)) {
                             return;
                         }
                         const now = Date.now();
                         let captured = 0;
                         for (const channel of channels) {
-                            if ((typeof channel.id !== "string") || !Array.isArray(channel.programs)) {
+                            if ((typeof channel["id"] !== "string") || !Array.isArray(channel["programs"])) {
                                 continue;
                             }
-                            for (const program of channel.programs) {
-                                if ((typeof program.eab === "string") && (typeof program.airingStart === "string") && (typeof program.airingEnd === "string")) {
-                                    if ((now >= new Date(program.airingStart).getTime()) && (now < new Date(program.airingEnd).getTime())) {
-                                        capturedCurrentEabs.set(channel.id, program.eab);
+                            for (const program of channel["programs"]) {
+                                if ((typeof program["eab"] === "string") && (typeof program["airingStart"] === "string") && (typeof program["airingEnd"] === "string")) {
+                                    if ((now >= new Date(program["airingStart"]).getTime()) && (now < new Date(program["airingEnd"]).getTime())) {
+                                        capturedCurrentEabs.set(channel["id"], program["eab"]);
                                         captured++;
                                         break;
                                     }
@@ -1084,7 +1093,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                             console.log("[HULU-DIAG] Listing response captured: " + String(captured) + " current EABs for details expansion.");
                         }
                         // If the target UUID is already known (from a details response that arrived first), look up its EAB in the freshly captured listing data. This
-                        // handles the "details first, listing second" ordering — the details parser set uuid but couldn't find the EAB yet.
+                        // handles the "details first, listing second" ordering - the details parser set uuid but couldn't find the EAB yet.
                         if (uuid && !eab) {
                             const capturedEab = capturedCurrentEabs.get(uuid);
                             if (capturedEab) {
@@ -1093,18 +1102,18 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                             }
                         }
                         // Signal that listing data is available. Any details request awaiting listingCapturedPromise will now proceed with expansion.
-                        if (listingCapturedResolve) {
-                            listingCapturedResolve();
-                            listingCapturedResolve = null;
+                        if (!listingCaptureSignaled) {
+                            signalListingCaptured();
+                            listingCaptureSignaled = true;
                         }
                     }).catch(() => { });
                 }
                 catch {
-                    // Response doesn't support clone() or json() — silently skip capture.
+                    // Response doesn't support clone() or json() - silently skip capture.
                 }
             }
             // Fire-and-forget: parses a details API response to extract the target channel's UUID for cold direct tune. On warm cache (uuid already set at install
-            // time), this is a no-op — the UUID is already available. On cold cache, this is the primary mechanism for discovering the target's UUID: the expanded
+            // time), this is a no-op - the UUID is already available. On cold cache, this is the primary mechanism for discovering the target's UUID: the expanded
             // details response contains channel_info for all ~123 channels, and we match by normalized name. After finding the UUID, looks up the EAB in the captured
             // listing data and calls tryResolveDirectTune to release the held playlist request.
             function captureDetailsData(response) {
@@ -1113,16 +1122,16 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                 }
                 try {
                     void response.clone().json().then((data) => {
-                        const items = data.items;
+                        const items = data["items"];
                         if (!Array.isArray(items)) {
                             return;
                         }
                         for (const item of items) {
-                            const info = item.channel_info;
-                            if (info && (typeof info.name === "string") && (typeof info.id === "string")) {
-                                const name = info.name.trim().toLowerCase().replace(/\s+/g, " ");
+                            const info = item["channel_info"];
+                            if (info && (typeof info["name"] === "string") && (typeof info["id"] === "string")) {
+                                const name = info["name"].trim().toLowerCase().replace(/\s+/g, " ");
                                 if (name === targetName) {
-                                    uuid = info.id;
+                                    uuid = info["id"];
                                     // eslint-disable-next-line no-console
                                     console.log("[HULU-DIAG] Details response: found UUID " + uuid + " for " + targetName + ".");
                                     // Look up the EAB for this UUID in already-captured listing data. If the listing response arrived before this details response, the EAB is
@@ -1139,7 +1148,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                     }).catch(() => { });
                 }
                 catch {
-                    // Response doesn't support clone() or json() — silently skip capture.
+                    // Response doesn't support clone() or json() - silently skip capture.
                 }
             }
             // Extracts the request body from either the init options or a cloned Request object. Returns null if the body is not a string and the input is not a
@@ -1154,7 +1163,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                 return null;
             }
             // Sends a fetch request with a modified body, reconstructing the request from a URL string when the input is a Request object. Using input.url as a
-            // string sidesteps the Fetch spec's body-lock check — getBodyText() locked the ReadableStream via input.clone().text(), and the spec checks lock status
+            // string sidesteps the Fetch spec's body-lock check - getBodyText() locked the ReadableStream via input.clone().text(), and the spec checks lock status
             // on the first argument BEFORE applying init overrides, causing a TypeError even though we provide a replacement body.
             async function fetchWithBody(input, init, body) {
                 if (input instanceof Request) {
@@ -1179,19 +1188,19 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                     if (listingBody) {
                         try {
                             const listingObj = JSON.parse(listingBody);
-                            if (Array.isArray(listingObj.channels)) {
-                                const existing = new Set(listingObj.channels);
+                            if (Array.isArray(listingObj["channels"])) {
+                                const existing = new Set(listingObj["channels"]);
                                 for (const id of cachedUuids) {
                                     existing.add(id);
                                 }
-                                listingObj.channels = [...existing];
+                                listingObj["channels"] = [...existing];
                                 const listingResponse = await fetchWithBody(input, init, JSON.stringify(listingObj));
                                 captureListingData(listingResponse);
                                 return listingResponse;
                             }
                         }
                         catch {
-                            // Body parse error — pass through unmodified.
+                            // Body parse error - pass through unmodified.
                         }
                     }
                     const listingPassthrough = await originalFetch(input, init);
@@ -1201,20 +1210,20 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                 // Expand details API requests to include EABs for all known channels. The mini-guide details request only covers ~7 visible channels (~19 EABs),
                 // but we have EABs from two sources: pre-injected cachedEabs from Node.js (available on warm tunes and subsequent cold tunes), and dynamically
                 // captured capturedCurrentEabs from the listing API response (the primary source on the first cold tune). Merging both ensures the details response
-                // returns channel_info (name→UUID mappings) for all ~123 channels on any tune, even the very first cold tune after a restart.
+                // returns channel_info (name->UUID mappings) for all ~123 channels on any tune, even the very first cold tune after a restart.
                 if (url.includes("guide.hulu.com") && url.includes("/guide/details")) {
                     // If the in-page EAB map is empty and no pre-injected EABs are available, wait for the listing response to be parsed before proceeding. This holds
-                    // the first details request for ~200-600ms until captureListingData resolves the Promise. The 2s timeout is a safety net — if the listing response
+                    // the first details request for ~200-600ms until captureListingData resolves the Promise. The 2s timeout is a safety net - if the listing response
                     // never arrives, the details request proceeds without expansion (same behavior as before).
                     if ((capturedCurrentEabs.size === 0) && (cachedEabs.length === 0)) {
-                        await Promise.race([listingCapturedPromise, new Promise((resolve) => { setTimeout(resolve, 2000); })]);
+                        await Promise.race([listingCapturedPromise, inPageTimeout(2000)]);
                     }
                     const detailsBody = await getBodyText(input, init);
                     if (detailsBody) {
                         try {
                             const detailsObj = JSON.parse(detailsBody);
-                            if (Array.isArray(detailsObj.eabs)) {
-                                const existing = new Set(detailsObj.eabs);
+                            if (Array.isArray(detailsObj["eabs"])) {
+                                const existing = new Set(detailsObj["eabs"]);
                                 // Add pre-injected EABs from Node.js cache (available on warm tunes and subsequent cold tunes with partial cache data).
                                 for (const id of cachedEabs) {
                                     existing.add(id);
@@ -1223,14 +1232,14 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                                 for (const capturedEab of capturedCurrentEabs.values()) {
                                     existing.add(capturedEab);
                                 }
-                                detailsObj.eabs = [...existing];
+                                detailsObj["eabs"] = [...existing];
                                 const expandedResponse = await fetchWithBody(input, init, JSON.stringify(detailsObj));
                                 captureDetailsData(expandedResponse);
                                 return expandedResponse;
                             }
                         }
                         catch {
-                            // Body parse error — pass through unmodified.
+                            // Body parse error - pass through unmodified.
                         }
                     }
                     const detailsPassthrough = await originalFetch(input, init);
@@ -1246,7 +1255,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                     // interceptor returns a 503 (safety net). When holdActive is false (set by __prismcastReleasePlaylist after fast-path failure), the playlist passes
                     // through with affiliate UUID capture for the click fallback.
                     if (holdActive) {
-                        await Promise.race([directTunePromise, new Promise((resolve) => { setTimeout(resolve, 8000); })]);
+                        await Promise.race([directTunePromise, inPageTimeout(8000)]);
                     }
                     if (!uuid || !eab) {
                         // Affiliate guide grid click fallback: holdActive was set to false by __prismcastReleasePlaylist, or was never enabled. The guide grid handles channel
@@ -1257,18 +1266,18 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                             if (affiliateBody) {
                                 try {
                                     const bodyObj = JSON.parse(affiliateBody);
-                                    if ((bodyObj.play_intent === "live") && (typeof bodyObj.channel_id === "string")) {
+                                    if ((bodyObj["play_intent"] === "live") && (typeof bodyObj["channel_id"] === "string")) {
                                         if (initialPlaylistSeen) {
                                             // eslint-disable-next-line no-console
-                                            console.log("[HULU-CACHE] " + targetName + "=" + bodyObj.channel_id);
+                                            console.log("[HULU-CACHE] " + targetName + "=" + bodyObj["channel_id"]);
                                         }
                                         initialPlaylistSeen = true;
                                     }
                                 }
                                 catch {
-                                    // Body parse error — skip capture.
+                                    // Body parse error - skip capture.
                                 }
-                                // Must use fetchWithBody — getBodyText may have locked the Request's ReadableStream via clone().
+                                // Must use fetchWithBody - getBodyText may have locked the Request's ReadableStream via clone().
                                 return fetchWithBody(input, init, affiliateBody);
                             }
                             return originalFetch(input, init);
@@ -1281,19 +1290,17 @@ async function resolveHuluDirectUrl(channelSelector, page) {
                     if (bodyText) {
                         try {
                             const bodyObj = JSON.parse(bodyText);
-                            if (bodyObj.play_intent === "live") {
-                                const originalChannelId = String(bodyObj.channel_id);
-                                // eslint-disable-next-line camelcase
-                                bodyObj.channel_id = uuid;
-                                // eslint-disable-next-line camelcase
-                                bodyObj.content_eab_id = eab;
+                            if (bodyObj["play_intent"] === "live") {
+                                const originalChannelId = String(bodyObj["channel_id"]);
+                                bodyObj["channel_id"] = uuid;
+                                bodyObj["content_eab_id"] = eab;
                                 // eslint-disable-next-line no-console
                                 console.log("[HULU-DIAG] Playlist swapped: channel_id " + originalChannelId + " -> " + uuid + ", eab -> " + eab);
                                 return await fetchWithBody(input, init, JSON.stringify(bodyObj));
                             }
                         }
                         catch {
-                            // Body parse error — pass through unmodified.
+                            // Body parse error - pass through unmodified.
                         }
                     }
                 }
@@ -1305,7 +1312,7 @@ async function resolveHuluDirectUrl(channelSelector, page) {
         LOG.debug("tuning:hulu", "Failed to install Hulu fetch interceptor: %s.", formatError(error));
         return null;
     }
-    // On cold cache (no UUID), fall through to the guide grid. The initial page load only provides Details API data for ~10 visible channels — the guide grid's
+    // On cold cache (no UUID), fall through to the guide grid. The initial page load only provides Details API data for ~10 visible channels - the guide grid's
     // Channels tab click triggers full expansion for all ~123 channels, and the interceptor captures UUID+EAB from those expanded responses to resolve the held
     // playlist. Affiliates additionally need position-based inference because their channel_info.name uses call signs rather than network names.
     if (!cachedUuid) {
@@ -1341,7 +1348,7 @@ async function discoverHuluChannels(page) {
         return buildHuluDiscoveredChannels();
     }
     // Set up response interception BEFORE navigation so we capture the initial details and listing API responses during page load. These responses populate the
-    // unified channel cache with UUID, programs, and display names for all ~130 channels — warming the tuning cache as a side effect of discovery. The same
+    // unified channel cache with UUID, programs, and display names for all ~130 channels - warming the tuning cache as a side effect of discovery. The same
     // setupDetailsResponseInterception function used by the tuning path ensures a single code path for all API response processing.
     setupDetailsResponseInterception(page);
     try {
@@ -1350,7 +1357,7 @@ async function discoverHuluChannels(page) {
     catch {
         return [];
     }
-    // Click the Channels tab to reveal the channel list and trigger full API expansion. Matches the tuning path's retry logic — if guide rows don't appear after
+    // Click the Channels tab to reveal the channel list and trigger full API expansion. Matches the tuning path's retry logic - if guide rows don't appear after
     // the first tab click, retry once with a longer delay in case the first click fired during a transitional state before the guide was fully interactive.
     const listSelector = "#CHANNELS";
     try {
@@ -1415,8 +1422,8 @@ async function discoverHuluChannels(page) {
     // Reassign sequential domIndex values across the full accumulated list so that inferLocalAffiliate's position-based logic works correctly. The original
     // domIndex values are from individual scroll windows (0-12) and are not meaningful across the full channel list.
     const indexedChannels = allChannels.map((ch, i) => ({ ...ch, domIndex: i }));
-    // Build a callSign → networkName map by reusing inferLocalAffiliate for each broadcast network. This is the same position-based inference the tuning strategy
-    // uses during binary search — a call sign channel occupies the alphabetical position where its network name would sort.
+    // Build a callSign -> networkName map by reusing inferLocalAffiliate for each broadcast network. This is the same position-based inference the tuning strategy
+    // uses during binary search - a call sign channel occupies the alphabetical position where its network name would sort.
     const affiliateMap = new Map();
     for (const network of NETWORK_NAMES_WITH_AFFILIATES) {
         const callSign = inferLocalAffiliate(indexedChannels, network);
@@ -1447,7 +1454,7 @@ async function discoverHuluChannels(page) {
         }
         return { channelSelector: ch.displayName, name: ch.displayName };
     });
-    // Do not cache empty results — leave the flag false so subsequent calls retry the full walk. Empty results can indicate no Hulu + Live TV subscription.
+    // Do not cache empty results - leave the flag false so subsequent calls retry the full walk. Empty results can indicate no Hulu + Live TV subscription.
     if (discovered.length > 0) {
         discovered.sort((a, b) => a.name.localeCompare(b.name));
         huluFullyDiscovered = true;