prismcast 1.2.1 → 1.3.1

package/dist/browser/channelSelection.js

@@ -1,974 +1,113 @@
-import { LOG, delay, evaluateWithAbort, formatError } from "../utils/index.js";
-import { CONFIG } from "../config/index.js";
-/* Multi-channel streaming sites (like USA Network) present multiple channels on a single page, with a program guide for each channel. Users must select which
- * channel they want to watch by clicking on a show in the guide. This module provides a strategy-based system for automating that channel selection.
- *
- * The strategy pattern allows different sites to have different selection mechanisms:
- * - guideGrid: Scroll a virtualized channel grid to the target channel via binary search on document.documentElement.scrollTop, then click the on-now program
- *   cell and play button (Hulu Live). Supports position-based inference for local affiliate call signs and a linear scan fallback.
- * - hboGrid: Discover the HBO tab page URL from the homepage menu bar, scrape the live channel tile rail for a matching channel name, and navigate to the
- *   extracted watch URL. Caches the tab URL across tunes with stale-cache fallback rediscovery (HBO Max).
- * - thumbnailRow: Find channel by matching image URL slug, click adjacent show entry on the same row (USA Network)
- * - tileClick: Find channel tile by matching image URL slug, click tile, then click play button on modal (Disney+ live)
- * - youtubeGrid: Find channel by aria-label in a non-virtualized EPG grid, extract the watch URL, and navigate directly (YouTube TV)
+/* Copyright(C) 2024-2026, HJD (https://github.com/hjdhjd). All rights reserved.
  *
- * Each strategy is a self-contained function that takes the page and channel identifier, and returns a success/failure result. The main selectChannel() function
- * delegates to the appropriate strategy based on the profile configuration.
- */
-// Base URLs for provider strategies that navigate to watch pages. Centralizing these avoids scattering the same origin string across scraper functions, navigation
-// calls, and URL construction sites within each strategy.
-const HBO_MAX_BASE_URL = "https://play.hbomax.com";
-const YOUTUBE_TV_BASE_URL = "https://tv.youtube.com";
-// Guide grid row number cache. Maps lowercased, trimmed channel names from data-testid attributes to their row numbers (from sr-only text). Populated passively
-// during binary search iterations and used for direct-scroll optimization on subsequent tunes. Session-scoped — cleared when the browser restarts.
-const guideRowCache = new Map();
+ * channelSelection.ts: Channel selection coordinator for multi-channel streaming sites.
+ */
+import { isChannelSelectionProfile } from "../types/index.js";
+import { LOG, delay } from "../utils/index.js";
+import { clearHboCache, hboGridStrategy } from "./tuning/hbo.js";
+import { clearHuluCache, guideGridStrategy } from "./tuning/hulu.js";
+import { clearSlingCache, slingGridStrategy } from "./tuning/sling.js";
+import { CHANNELS } from "../channels/index.js";
+import { CONFIG } from "../config/index.js";
+import { foxGridStrategy } from "./tuning/fox.js";
+import { thumbnailRowStrategy } from "./tuning/thumbnailRow.js";
+import { tileClickStrategy } from "./tuning/tileClick.js";
+import { youtubeGridStrategy } from "./tuning/youtubeTv.js";
+// Strategy dispatch registry. Maps strategy names from ChannelSelectionStrategy to their implementation functions.
+const strategies = {
+    foxGrid: foxGridStrategy,
+    guideGrid: guideGridStrategy,
+    hboGrid: hboGridStrategy,
+    slingGrid: slingGridStrategy,
+    thumbnailRow: thumbnailRowStrategy,
+    tileClick: tileClickStrategy,
+    youtubeGrid: youtubeGridStrategy
+};
 /**
  * Clears all channel selection caches. Called by handleBrowserDisconnect() in browser/index.ts when the browser restarts, since cached state (guide row positions,
  * discovered page URLs) may be stale in a new browser session.
  */
 export function clearChannelSelectionCaches() {
-    guideRowCache.clear();
-    hboTabUrl = null;
+    clearHboCache();
+    clearHuluCache();
+    clearSlingCache();
 }
-/* These utilities are shared across channel selection strategies. They handle common operations like finding elements, scrolling, and clicking.
- */
 /**
  * Clicks at the specified coordinates after a brief settle delay. The delay allows scroll animations and lazy-loaded content to finish before the click fires.
  * Callers are responsible for scrolling the target element into view (typically via scrollIntoView inside a page.evaluate call) before invoking this function.
+ * Exported for use by tuning strategy files (thumbnailRow, tileClick, hulu).
  * @param page - The Puppeteer page object.
  * @param target - The x/y coordinates to click.
  * @returns True if the click was executed.
  */
-async function scrollAndClick(page, target) {
+export async function scrollAndClick(page, target) {
     // Brief delay after scrolling for any animations or lazy-loaded content to settle.
     await delay(200);
     // Click the target coordinates to switch to the channel.
     await page.mouse.click(target.x, target.y);
     return true;
 }
-/* Each strategy implements a different approach to finding and selecting channels. Strategies are self-contained functions that can be tested independently.
- */
-/**
- * Thumbnail row strategy: finds a channel by matching the slug in thumbnail image URLs, then clicks an adjacent clickable element on the same row. This strategy
- * works for sites like USA Network where channels are displayed as rows with a thumbnail on the left and program entries to the right.
- *
- * The selection process:
- * 1. Search all images on the page for one whose src URL contains the channel slug
- * 2. Verify the image has dimensions (is rendered and visible)
- * 3. Walk up the DOM to find a container wide enough to hold both thumbnail and guide entries
- * 4. Search for clickable elements (links, buttons, cards) to the right of the thumbnail on the same row
- * 5. Fall back to divs with cursor:pointer if no semantic clickables found
- * 6. Click the found element to switch to the channel
- * @param page - The Puppeteer page object.
- * @param channelSlug - The literal string to match in thumbnail image URLs.
- * @returns Result object with success status and optional failure reason.
- */
-async function thumbnailRowStrategy(page, channelSlug) {
-    // Find clickable element by evaluating DOM. The logic walks through the page looking for channel thumbnail images, then finds clickable show entries on the
-    // same row.
-    const clickTarget = await evaluateWithAbort(page, (slug) => {
-        const images = document.querySelectorAll("img");
-        for (const img of Array.from(images)) {
-            // Channel thumbnails have URLs containing the channel slug pattern. Match against the src URL.
-            if (img.src && img.src.includes(slug)) {
-                const imgRect = img.getBoundingClientRect();
-                // Verify the image has dimensions (is actually rendered and visible).
-                if ((imgRect.width > 0) && (imgRect.height > 0)) {
-                    // Found the channel thumbnail. Now walk up the DOM tree to find a container that holds both the thumbnail and the guide entries for this row.
-                    let rowContainer = img.parentElement;
-                    while (rowContainer && (rowContainer !== document.body)) {
-                        const containerRect = rowContainer.getBoundingClientRect();
-                        // Look for a container significantly wider than the thumbnail (indicating it contains more than just the image). The factor of 2 is a heuristic
-                        // that works for typical channel guide layouts.
-                        if (containerRect.width > (imgRect.width * 2)) {
-                            // This container is wide enough to contain guide entries. Search for clickable elements (show cards) to the right of the thumbnail.
-                            const clickables = rowContainer.querySelectorAll("a, button, [role=\"button\"], [onclick], [class*=\"card\"], [class*=\"program\"], [class*=\"show\"], [class*=\"episode\"]");
-                            const imgCenterY = imgRect.y + (imgRect.height / 2);
-                            for (const clickable of Array.from(clickables)) {
-                                const clickRect = clickable.getBoundingClientRect();
-                                const clickCenterY = clickRect.y + (clickRect.height / 2);
-                                // The guide entry must meet these criteria:
-                                // - To the right of the thumbnail (with small tolerance for overlapping borders)
-                                // - Has dimensions (is visible)
-                                // - On the same row (vertical center within thumbnail height)
-                                const isRightOfThumbnail = clickRect.x > (imgRect.x + imgRect.width - 10);
-                                const hasDimensions = (clickRect.width > 0) && (clickRect.height > 0);
-                                const isSameRow = Math.abs(clickCenterY - imgCenterY) < imgRect.height;
-                                if (isRightOfThumbnail && hasDimensions && isSameRow) {
-                                    // Found a suitable click target. Scroll it into view and return its center coordinates.
-                                    clickable.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                                    const newRect = clickable.getBoundingClientRect();
-                                    return { x: newRect.x + (newRect.width / 2), y: newRect.y + (newRect.height / 2) };
-                                }
-                            }
-                            // Fallback: if no semantically clickable elements found, look for divs with cursor: pointer styling. These are often custom-styled click
-                            // handlers.
-                            const allDivs = rowContainer.querySelectorAll("div");
-                            for (const div of Array.from(allDivs)) {
-                                const divRect = div.getBoundingClientRect();
-                                const divCenterY = divRect.y + (divRect.height / 2);
-                                const style = window.getComputedStyle(div);
-                                const isRightOfThumbnail = divRect.x > (imgRect.x + imgRect.width - 10);
-                                const hasDimensions = (divRect.width > 20) && (divRect.height > 20);
-                                const isClickable = style.cursor === "pointer";
-                                const isSameRow = Math.abs(divCenterY - imgCenterY) < imgRect.height;
-                                if (isRightOfThumbnail && hasDimensions && isClickable && isSameRow) {
-                                    div.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                                    const newRect = div.getBoundingClientRect();
-                                    return { x: newRect.x + (newRect.width / 2), y: newRect.y + (newRect.height / 2) };
-                                }
-                            }
-                        }
-                        rowContainer = rowContainer.parentElement;
-                    }
-                    // Ultimate fallback: click a fixed offset to the right of the thumbnail. This is a last resort if the guide structure doesn't match our
-                    // expectations.
-                    img.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                    const newImgRect = img.getBoundingClientRect();
-                    return { x: newImgRect.x + newImgRect.width + 50, y: newImgRect.y + (newImgRect.height / 2) };
-                }
-            }
-        }
-        // Channel thumbnail not found in any images.
-        return null;
-    }, [channelSlug]);
-    if (clickTarget) {
-        await scrollAndClick(page, clickTarget);
-        // Poll for the video readyState to drop below 3, indicating the channel switch has started loading new content. This replaces a fixed post-click delay with
-        // early exit. If no video exists yet or readyState never drops (channel already selected), the timeout expires harmlessly and waitForVideoReady() handles the
-        // rest.
-        try {
-            await page.waitForFunction(() => {
-                const v = document.querySelector("video");
-                return !v || (v.readyState < 3);
-            }, { timeout: CONFIG.playback.channelSwitchDelay });
-        }
-        catch {
-            // Timeout — readyState never dropped. Proceed normally.
-        }
-        return { success: true };
-    }
-    return { reason: "Channel thumbnail not found in page images.", success: false };
-}
-/**
- * Tile click strategy: finds a channel by matching the slug in tile image URLs, clicks the tile to open an entity modal, then clicks a "watch live" play button on
- * the modal. This strategy works for sites like Disney+ where live channels are displayed as tiles in a horizontal shelf, and selecting one opens a modal with a
- * play button to start the live stream.
- *
- * The selection process:
- * 1. Search all images on the page for one whose src URL contains the channel slug
- * 2. Walk up the DOM to find the nearest clickable ancestor (the tile container)
- * 3. Scroll the tile into view and click it
- * 4. Wait for the play button to appear on the resulting modal
- * 5. Click the play button to start live playback
- * @param page - The Puppeteer page object.
- * @param channelSlug - The literal string to match in tile image URLs.
- * @returns Result object with success status and optional failure reason.
- */
-async function tileClickStrategy(page, channelSlug) {
-    // Step 1: Find the channel tile by matching the slug in a descendant image's src URL. Live channels are displayed as tiles in a horizontal shelf, each containing
-    // an image with the network name in the URL label parameter (e.g., "poster_linear_espn_none"). We match the image, then walk up the DOM to find the nearest
-    // clickable ancestor that represents the entire tile.
-    const tileTarget = await evaluateWithAbort(page, (slug) => {
-        const images = document.querySelectorAll("img");
-        for (const img of Array.from(images)) {
-            if (img.src && img.src.includes(slug)) {
-                const imgRect = img.getBoundingClientRect();
-                // Verify the image has dimensions (is actually rendered and visible). This matches the pattern in thumbnailRowStrategy and provides defense-in-depth if the
-                // wait phase timed out before the image fully loaded.
-                if ((imgRect.width > 0) && (imgRect.height > 0)) {
-                    // Walk up the DOM to find the nearest clickable ancestor wrapping the tile. Check for semantic clickable elements (<a>, <button>, role="button") and
-                    // elements with explicit click handlers first. Track cursor:pointer elements as a fallback for sites using custom click handlers without semantic markup.
-                    let ancestor = img.parentElement;
-                    let pointerFallback = null;
-                    while (ancestor && (ancestor !== document.body)) {
-                        const tag = ancestor.tagName;
-                        // Semantic clickable elements are the most reliable indicators of an interactive tile container.
-                        if ((tag === "A") || (tag === "BUTTON") || (ancestor.getAttribute("role") === "button") || ancestor.hasAttribute("onclick")) {
-                            ancestor.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                            const rect = ancestor.getBoundingClientRect();
-                            if ((rect.width > 0) && (rect.height > 0)) {
-                                return { x: rect.x + (rect.width / 2), y: rect.y + (rect.height / 2) };
-                            }
-                        }
-                        // Track the nearest cursor:pointer ancestor with reasonable dimensions as a fallback.
-                        if (!pointerFallback) {
-                            const rect = ancestor.getBoundingClientRect();
-                            if ((rect.width > 20) && (rect.height > 20) && (window.getComputedStyle(ancestor).cursor === "pointer")) {
-                                pointerFallback = ancestor;
-                            }
-                        }
-                        ancestor = ancestor.parentElement;
-                    }
-                    // Fallback: use cursor:pointer ancestor if no semantic clickable was found above.
-                    if (pointerFallback) {
-                        pointerFallback.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                        const rect = pointerFallback.getBoundingClientRect();
-                        if ((rect.width > 0) && (rect.height > 0)) {
-                            return { x: rect.x + (rect.width / 2), y: rect.y + (rect.height / 2) };
-                        }
-                    }
-                }
-            }
-        }
-        return null;
-    }, [channelSlug]);
-    if (!tileTarget) {
-        return { reason: "Channel tile not found in page images.", success: false };
-    }
-    // Click the channel tile to open the entity modal.
-    await scrollAndClick(page, tileTarget);
-    // Step 2: Wait for the "WATCH LIVE" button to appear on the entity modal. The button is an <a> element with a specific data-testid attribute. After clicking the
-    // tile, the site performs a SPA navigation that renders a modal with playback options.
-    const playButtonSelector = "[data-testid=\"live-modal-watch-live-action-button\"]";
-    try {
-        await page.waitForSelector(playButtonSelector, { timeout: CONFIG.streaming.videoTimeout });
-    }
-    catch {
-        return { reason: "Play button did not appear after clicking channel tile.", success: false };
-    }
-    // Get the play button coordinates for clicking.
-    const playTarget = await evaluateWithAbort(page, (selector) => {
-        const button = document.querySelector(selector);
-        if (!button) {
-            return null;
-        }
-        button.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-        const rect = button.getBoundingClientRect();
-        if ((rect.width > 0) && (rect.height > 0)) {
-            return { x: rect.x + (rect.width / 2), y: rect.y + (rect.height / 2) };
-        }
-        return null;
-    }, [playButtonSelector]);
-    if (!playTarget) {
-        return { reason: "Play button found but has no dimensions.", success: false };
-    }
-    // Click the play button to start live playback.
-    await scrollAndClick(page, playTarget);
-    return { success: true };
-}
-/**
- * YouTube TV grid strategy: finds a channel in the non-virtualized EPG grid at tv.youtube.com/live by querying the aria-label attribute on thumbnail endpoint
- * elements. All ~256 channel rows are present in the DOM simultaneously, so a single querySelector locates the target channel. The strategy extracts the watch
- * URL from the matching anchor element and navigates directly — no scrolling, clicking, or timing workarounds needed.
- *
- * The selection process:
- * 1. Wait for ytu-epg-row elements to confirm the guide grid has loaded.
- * 2. Find the target channel using a case-insensitive aria-label CSS selector.
- * 3. Extract the href attribute and validate it starts with "watch/" (not "live" or "browse/").
- * 4. Navigate to the full watch URL via page.goto().
- * @param page - The Puppeteer page object.
- * @param channelName - The channel name or network name to match against aria-label attributes (e.g., "CNN", "ESPN", "NBC" for local affiliates).
- * @returns Result object with success status and optional failure reason.
- */
-async function youtubeGridStrategy(page, channelName) {
-    // Wait for the EPG grid to render. All ~256 rows load simultaneously (no virtualization), so once any row exists, all channels are queryable.
-    try {
-        await page.waitForSelector("ytu-epg-row", { timeout: CONFIG.streaming.videoTimeout });
-    }
-    catch {
-        return { reason: "YouTube TV guide grid did not load.", success: false };
-    }
-    // Known alternate channel names for affiliates that vary by market. CW appears as "WGN" in some markets. PBS affiliates appear under local call letters (e.g.,
-    // WTTW, KQED) rather than "PBS", so we list the major market call letters to cover most users. Each alternate is tried after the primary name fails both exact and
-    // prefix+digit matching. Users in smaller markets override via custom channel entries with their local call letters as the channelSelector.
-    const CHANNEL_ALTERNATES = {
-        "cw": ["WGN"],
-        "pbs": [
-            "GBH", "KAET", "KBTC", "KCET", "KCTS", "KERA", "KLCS", "KOCE", "KPBS", "KQED", "KRMA", "KUHT", "KVIE", "MPT", "NJ PBS", "THIRTEEN", "TPT", "WETA", "WGBH", "WHYY",
-            "WLIW", "WNED", "WNET", "WNIT", "WPBA", "WPBT", "WTTW", "WTVS", "WXEL"
-        ]
-    };
-    // Build the list of names to try: the primary name first, then any known alternates for markets where the affiliate uses a different name. The eslint disable is
-    // needed because TypeScript's Record indexing doesn't capture that the key may not exist at runtime.
-    const alternates = CHANNEL_ALTERNATES[channelName.toLowerCase()];
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    const namesToTry = alternates ? [channelName, ...alternates] : [channelName];
-    // Find the watch URL for the target channel. For each name in the list, first tries an exact case-insensitive aria-label match. If that fails, falls back to a
-    // prefix+digit match for local affiliates — YouTube TV displays locals as "{Network} {Number}" (e.g., "NBC 5", "ABC 7", "FOX 32"), so a channelSelector of "NBC"
-    // can automatically resolve to the user's local affiliate. The prefix fallback requires a space followed by a digit after the network name to avoid false positives
-    // like "NBC Sports Chicago".
-    const watchPath = await evaluateWithAbort(page, (names) => {
-        // Helper to extract and validate a watch URL from an anchor element. Returns the href if it points to a streamable watch page, null otherwise.
-        const extractWatchHref = (anchor) => {
-            if (!anchor) {
-                return null;
-            }
-            const href = anchor.getAttribute("href");
-            // Validate the href points to a streamable watch page. Channels with "live" or "browse/" hrefs are premium add-ons or info pages that cannot be streamed.
-            if (!href || !href.startsWith("watch/")) {
-                return null;
-            }
-            return href;
-        };
-        // Try each name in order. The primary channel name is tried first, followed by any known alternates.
-        for (const name of names) {
-            // Try exact match first. The CSS "i" flag enables case-insensitive matching to handle variations in capitalization between the channel selector and the guide.
-            const exactSelector = "ytu-endpoint.tenx-thumb[aria-label=\"watch " + name + "\" i] a";
-            const exactResult = extractWatchHref(document.querySelector(exactSelector));
-            if (exactResult) {
-                return exactResult;
-            }
-            // Fallback: prefix + digit match for local affiliates. Find all thumbnails whose aria-label starts with "watch {Name} " and filter to those where the next
-            // character is a digit, matching the "{Network} {Number}" pattern (e.g., "NBC 5", "ABC 7") while excluding unrelated channels (e.g., "NBC Sports Chicago").
-            const prefixSelector = "ytu-endpoint.tenx-thumb[aria-label^=\"watch " + name + " \" i] a";
-            const candidates = document.querySelectorAll(prefixSelector);
-            const prefix = "watch " + name + " ";
-            for (const candidate of Array.from(candidates)) {
-                const parent = candidate.closest("ytu-endpoint.tenx-thumb");
-                const label = parent?.getAttribute("aria-label") ?? "";
-                const suffix = label.slice(prefix.length);
-                // Accept only if the remainder starts with a digit — this is the local affiliate channel number.
-                if ((suffix.length > 0) && (suffix.charCodeAt(0) >= 48) && (suffix.charCodeAt(0) <= 57)) {
-                    return extractWatchHref(candidate);
-                }
-            }
-        }
-        return null;
-    }, [namesToTry]);
-    if (!watchPath) {
-        return { reason: "Channel " + channelName + " not found in YouTube TV guide or is not streamable.", success: false };
-    }
-    // Navigate directly to the watch URL. This auto-starts playback without any click interaction needed.
-    const watchUrl = YOUTUBE_TV_BASE_URL + "/" + watchPath;
-    LOG.info("Navigating to YouTube TV watch URL for %s.", channelName);
-    try {
-        await page.goto(watchUrl, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "load" });
-    }
-    catch (error) {
-        return { reason: "Failed to navigate to YouTube TV watch page: " + formatError(error) + ".", success: false };
-    }
-    return { success: true };
-}
-// Module-level cache for the HBO tab page URL discovered from the homepage menu bar. Cleared on browser disconnect (via clearChannelSelectionCaches) and inline
-// when the cached URL turns out to be stale (the channel rail is not found at the cached URL).
-let hboTabUrl = null;
-/**
- * Scrapes the HBO tab URL from the homepage menu bar. The HBO brand page is linked via an `a[aria-label="H B O"]` element in the top navigation. The href attribute
- * contains a relative path like `/channel/c0d1f27a-...` which we combine with the base URL to form the full page URL.
- * @param page - The Puppeteer page object, expected to be on the HBO Max homepage.
- * @returns The full HBO tab page URL, or null if the tab link was not found.
- */
-async function scrapeHboTabUrl(page) {
-    // Wait for the HBO tab link to appear in the menu bar. The homepage is a single-page application that renders the navigation dynamically after the initial HTML
-    // shell loads. Without this wait, the evaluate call below would run against an incomplete DOM and fail to find the tab link.
-    const HBO_TAB_SELECTOR = "a[aria-label=\"H B O\"]";
-    try {
-        await page.waitForSelector(HBO_TAB_SELECTOR, { timeout: 5000 });
-    }
-    catch {
-        return null;
-    }
-    const href = await evaluateWithAbort(page, (selector) => {
-        const tab = document.querySelector(selector);
-        if (!tab) {
-            return null;
-        }
-        return tab.getAttribute("href");
-    }, [HBO_TAB_SELECTOR]);
-    if (!href) {
-        return null;
-    }
-    return HBO_MAX_BASE_URL + href;
-}
-/**
- * Scrapes the HBO Channels tile rail on the HBO tab page for a watch URL matching the given channel name. The rail section contains tiles for each live channel,
- * each with a backup text `<p aria-hidden="true">` element containing the channel name and an `<a>` with href pointing to the watch page.
- * @param page - The Puppeteer page object, expected to be on the HBO tab page.
- * @param channelName - The channel name to match (e.g., "HBO", "HBO Hits"). Case-insensitive.
- * @returns Object with `railFound` indicating whether the rail section was present, and `watchPath` containing the relative watch URL if the channel was found.
- */
-async function scrapeHboChannelRail(page, channelName) {
-    const HBO_RAIL_SELECTOR = "section[data-testid=\"hbo-page-rail-distribution-channels-us_rail\"]";
-    // Wait for the distribution channels rail section to appear. If it doesn't appear, the tab URL may be stale or the page structure changed.
-    try {
-        await page.waitForSelector(HBO_RAIL_SELECTOR, { timeout: CONFIG.streaming.videoTimeout });
-    }
-    catch {
-        return { railFound: false, watchPath: null };
-    }
-    // The rail uses lazy loading via IntersectionObserver — tile content only populates when the rail is visible in the viewport. The rail section element appears
-    // immediately with skeleton PhantomTile placeholders, but the actual channel tiles (with names and watch URLs) are fetched asynchronously after the rail scrolls
-    // into view. We scroll the rail into view and then wait for anchor elements to appear, indicating the tiles have loaded.
-    await page.evaluate((selector) => {
-        document.querySelector(selector)?.scrollIntoView({ behavior: "instant", block: "center" });
-    }, HBO_RAIL_SELECTOR);
-    try {
-        await page.waitForSelector(HBO_RAIL_SELECTOR + " a", { timeout: 5000 });
-    }
-    catch {
-        return { railFound: false, watchPath: null };
-    }
-    // Scrape the rail for the target channel's watch URL. Each tile in the rail contains an anchor with the watch URL and a backup text paragraph with the channel name.
-    const watchPath = await evaluateWithAbort(page, (selector, target) => {
-        const rail = document.querySelector(selector);
-        if (!rail) {
-            return null;
-        }
-        const targetLower = target.toLowerCase();
-        const anchors = rail.querySelectorAll("a");
-        for (const anchor of Array.from(anchors)) {
-            // The channel name appears in a <p aria-hidden="true"> element within the tile. This is the backup text that displays the channel name when the tile
-            // image fails to load.
-            const nameEl = anchor.querySelector("p[aria-hidden=\"true\"]");
-            if (!nameEl) {
-                continue;
-            }
-            const name = nameEl.textContent.trim().toLowerCase();
-            if (name !== targetLower) {
-                continue;
-            }
-            const href = anchor.getAttribute("href");
-            // Validate that the href points to a live channel watch page. Watch URLs follow the pattern /channel/watch/{channelUUID}/{programUUID}.
-            if (href && href.includes("/channel/watch/")) {
-                return href;
-            }
-        }
-        return null;
-    }, [HBO_RAIL_SELECTOR, channelName]);
-    return { railFound: true, watchPath };
-}
-/**
- * HBO grid strategy: discovers the HBO channels tab URL from the homepage menu bar, navigates to the tab page, scrapes the live channel rail for the target channel's
- * watch URL, and navigates to it. Caches the tab URL across tunes and falls back to rediscovery if the cached URL is stale (rail not found at the cached location).
- *
- * The strategy handles three navigations per tune:
- * 1. Homepage (already loaded by navigateToPage) → scrape menu bar for tab URL (or use cache)
- * 2. Tab page → scrape channel rail for watch URL
- * 3. Watch page → video playback begins
- *
- * When the cached tab URL is stale (rail section not found), the strategy clears the cache, navigates back to the homepage, rediscovers the tab URL, and retries.
- * This fallback triggers at most once per tune attempt.
- * @param page - The Puppeteer page object, expected to be on the HBO Max homepage.
- * @param channelName - The channel name to find in the rail (e.g., "HBO", "HBO Hits").
- * @returns Result object with success status and optional failure reason.
- */
-async function hboGridStrategy(page, channelName) {
-    let usedCache = false;
-    // Phase 1: Navigate to the HBO tab page. Use cached URL if available, otherwise discover it from the homepage menu bar.
-    if (hboTabUrl) {
-        usedCache = true;
-        LOG.debug("Using cached HBO tab URL: %s.", hboTabUrl);
-    }
-    else {
-        const discovered = await scrapeHboTabUrl(page);
-        if (!discovered) {
-            return { reason: "HBO tab not found in homepage menu bar. HBO Max subscription may not be active.", success: false };
-        }
-        hboTabUrl = discovered;
-        LOG.debug("Discovered HBO tab URL: %s.", hboTabUrl);
-    }
-    try {
-        await page.goto(hboTabUrl, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "load" });
-    }
-    catch (error) {
-        return { reason: "Failed to navigate to HBO tab page: " + formatError(error) + ".", success: false };
-    }
-    // Phase 2: Scrape the channel rail for the target channel's watch URL.
-    let railResult = await scrapeHboChannelRail(page, channelName);
-    // Fallback: if the rail was not found and we used a cached URL, the cache may be stale. Clear it, navigate back to the homepage, rediscover the tab URL, and retry.
-    if (!railResult.railFound && usedCache) {
-        LOG.info("HBO channel rail not found at cached URL. Rediscovering tab URL from homepage.");
-        hboTabUrl = null;
-        try {
-            await page.goto(HBO_MAX_BASE_URL, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "load" });
-        }
-        catch (error) {
-            return { reason: "Failed to navigate back to HBO Max homepage: " + formatError(error) + ".", success: false };
-        }
-        const rediscovered = await scrapeHboTabUrl(page);
-        if (!rediscovered) {
-            return { reason: "HBO tab not found in homepage menu bar after cache invalidation.", success: false };
-        }
-        hboTabUrl = rediscovered;
-        LOG.debug("Rediscovered HBO tab URL: %s.", hboTabUrl);
-        try {
-            await page.goto(hboTabUrl, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "load" });
-        }
-        catch (error) {
-            return { reason: "Failed to navigate to rediscovered HBO tab page: " + formatError(error) + ".", success: false };
-        }
-        railResult = await scrapeHboChannelRail(page, channelName);
-        if (!railResult.railFound) {
-            return { reason: "HBO channel rail not found at rediscovered URL. Site structure may have changed.", success: false };
-        }
-    }
-    if (!railResult.railFound) {
-        return { reason: "HBO channel rail not found on tab page.", success: false };
-    }
-    if (!railResult.watchPath) {
-        return { reason: "Channel " + channelName + " not found in HBO channel rail.", success: false };
-    }
-    // Phase 3: Navigate to the watch URL to start playback.
-    const watchUrl = HBO_MAX_BASE_URL + railResult.watchPath;
-    LOG.info("Navigating to HBO Max watch URL for %s.", channelName);
-    try {
-        await page.goto(watchUrl, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "load" });
-    }
-    catch (error) {
-        return { reason: "Failed to navigate to HBO Max watch page: " + formatError(error) + ".", success: false };
-    }
-    return { success: true };
-}
-/**
- * Reads all rendered channel containers from the guide grid, extracting their names from data-testid attributes and row numbers from sr-only text. Populates the
- * row number cache as a side effect.
- * @param page - The Puppeteer page object.
- * @returns Array of rendered channels in DOM order, or null if no channels are rendered.
- */
-async function readRenderedChannels(page) {
-    const channels = await page.evaluate(() => {
-        const containers = document.querySelectorAll("[data-testid^=\"live-guide-channel-kyber-\"]");
-        if (containers.length === 0) {
-            return null;
-        }
-        const prefix = "live-guide-channel-kyber-";
-        const results = [];
-        for (const el of Array.from(containers)) {
-            const testid = el.getAttribute("data-testid") ?? "";
-            const name = testid.slice(prefix.length).trim().replace(/\s+/g, " ").toLowerCase();
-            // Extract row number from sr-only text. Format: "{Name} Details, row {N} of {Total}. ..."
-            let rowNumber = -1;
-            const btn = el.querySelector("[data-testid=\"live-guide-channel-button\"]");
-            if (btn) {
-                const srOnly = btn.querySelector(".sr-only, [class*=\"sr-only\"]");
-                if (srOnly) {
-                    const match = srOnly.textContent.match(/row (\d+) of/);
-                    if (match) {
-                        // Row numbers in sr-only text are 1-based. Convert to 0-based for scroll offset calculation.
-                        rowNumber = parseInt(match[1], 10) - 1;
-                    }
-                }
-            }
-            results.push({ name, rowNumber });
-        }
-        return results;
-    });
-    if (!channels) {
-        return null;
-    }
-    // Assign DOM indices and populate the row number cache.
-    const rendered = [];
-    for (let i = 0; i < channels.length; i++) {
-        const ch = channels[i];
-        rendered.push({ domIndex: i, name: ch.name, rowNumber: ch.rowNumber });
-        // Cache the row number for future direct-scroll lookups.
-        if (ch.rowNumber >= 0) {
-            guideRowCache.set(ch.name, ch.rowNumber);
-        }
-    }
-    return rendered;
-}
-/**
- * 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
- * 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.
- * @returns Center coordinates of the on-now cell, or null if not found.
- */
-async function locateOnNowCell(page, targetName) {
-    return evaluateWithAbort(page, (target) => {
-        const prefix = "live-guide-channel-kyber-";
-        const containers = document.querySelectorAll("[data-testid^=\"" + prefix + "\"]");
-        for (const el of Array.from(containers)) {
-            const testid = el.getAttribute("data-testid") ?? "";
-            const name = testid.slice(prefix.length).trim().replace(/\s+/g, " ").toLowerCase();
-            if (name === target) {
-                const row = el.closest("[data-testid=\"live-guide-row\"]");
-                if (!row) {
-                    return null;
-                }
-                const onNow = row.querySelector(".LiveGuideProgram--first");
-                if (!onNow) {
-                    return null;
-                }
-                onNow.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-                const rect = onNow.getBoundingClientRect();
-                if ((rect.width > 0) && (rect.height > 0)) {
-                    return { x: rect.x + (rect.width / 2), y: rect.y + (rect.height / 2) };
-                }
-                return null;
-            }
-        }
-        return null;
-    }, [targetName]);
-}
-// US broadcast call sign pattern. Local affiliate stations have 3-4 uppercase letter call signs starting with W (east of the Mississippi) or K (west). This
-// 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;
 // Normalizes a channel name for case-insensitive, whitespace-tolerant comparison. Trims leading and trailing whitespace, collapses internal whitespace sequences
 // (including non-breaking spaces, tabs, and other Unicode whitespace matched by \s) into a single regular space, and lowercases. This handles data-testid values
 // with trailing spaces (e.g., "WLS "), double spaces, or non-breaking space characters that would otherwise cause exact match failures.
-function normalizeChannelName(name) {
+// Exported for use by tuning strategy files (hulu, sling).
+export function normalizeChannelName(name) {
     return name.trim().replace(/\s+/g, " ").toLowerCase();
 }
 /**
- * Position-based inference for local affiliates. When binary search returns "missing" (target name sorts between rendered channels but no exact match), this
- * function identifies the local affiliate at the target's alphabetical insertion point.
- *
- * The guide sorts local affiliates by their network name (ABC, CBS, NBC, etc.), but displays call signs (WLS, WBBM, WMAQ) in data-testid. The binary search
- * converges to the correct scroll position because the target network name sorts correctly, but the name match fails because the data-testid contains the call
- * sign. The affiliate occupies the DOM position where the network name would be if it existed.
- *
- * Algorithm:
- * 1. Filter rendered channels to non-call-sign names (these sort correctly by their displayed name)
- * 2. Find where the target would insert alphabetically among the non-call-sign neighbors
- * 3. The channel at the DOM position between those two neighbors is the local affiliate
- * @param rendered - The rendered channels in DOM order.
- * @param targetName - The lowercased target channel name.
- * @returns The name of the inferred local affiliate channel, or null if inference fails.
- */
-function inferLocalAffiliate(rendered, targetName) {
-    // Build a list of non-call-sign channels with their DOM indices. These channels sort alphabetically by their displayed name and serve as position anchors.
-    const anchors = [];
-    for (const ch of rendered) {
-        if (!CALL_SIGN_PATTERN.test(ch.name)) {
-            anchors.push(ch);
-        }
-    }
-    // If no non-call-sign channels are rendered, we have no position anchors and cannot infer the affiliate.
-    if (anchors.length === 0) {
-        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.
-    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;
-    }
-    else if (insertBeforeIndex === -1) {
-        // Target sorts after all anchors. Look for call signs after the last anchor.
-        lowerDomIndex = anchors[anchors.length - 1].domIndex;
-        upperDomIndex = rendered.length;
+ * Logs available channel names from a provider's guide grid when channel selection fails. Produces an actionable log message listing channel names that users can
+ * use as `channelSelector` values in user-defined channels. When `presetSuffix` is provided, channels already covered by built-in preset definitions are filtered
+ * out so users see only channels that require manual configuration. When omitted (small channel sets like Fox or HBO), all channels are logged unfiltered.
+ * @param options - Diagnostic dump configuration.
+ * @param options.additionalKnownNames - Extra names to exclude from the filtered list (e.g., CHANNEL_ALTERNATES values for YTTV).
+ * @param options.availableChannels - Sorted list of channel names discovered in the guide grid.
+ * @param options.channelName - The channelSelector value that failed to match, for the log message.
+ * @param options.guideUrl - The URL of the provider's guide page, included in the log message so users know what to set as the channel URL.
+ * @param options.presetSuffix - Key suffix to filter preset channels (e.g., "-yttv", "-hulu"). Omit for small unfiltered channel sets.
+ * @param options.providerName - Human-readable provider name for the log message (e.g., "YouTube TV", "Hulu").
+ */
+export function logAvailableChannels(options) {
+    const { additionalKnownNames, availableChannels, channelName, guideUrl, presetSuffix, providerName } = options;
+    if (availableChannels.length === 0) {
+        return;
+    }
+    let filteredChannels;
+    let countLabel;
+    if (presetSuffix) {
+        // Collect all channelSelector values from preset channels with this suffix, lowercased for case-insensitive comparison.
+        const knownSelectors = Object.entries(CHANNELS)
+            .filter(([key]) => key.endsWith(presetSuffix))
+            .map(([, ch]) => (ch.channelSelector ?? "").toLowerCase())
+            .filter((s) => s.length > 0);
+        // Include additional known names (e.g., CHANNEL_ALTERNATES values for YTTV) so those are also filtered out.
+        if (additionalKnownNames) {
+            for (const name of additionalKnownNames) {
+                knownSelectors.push(name.toLowerCase());
+            }
+        }
+        // Filter to channels not matched by any known selector. A channel is "covered" if a preset would find it via exact match (with parenthetical suffix stripped)
+        // or prefix+digit match. This mirrors the strategy's own matching tiers so users see only channels that genuinely need manual configuration.
+        filteredChannels = availableChannels.filter((name) => {
+            const lower = name.toLowerCase();
+            const stripped = lower.replace(/ \(.*\)$/, "");
+            return !knownSelectors.some((sel) => {
+                return (stripped === sel) ||
+                    (lower.startsWith(sel + " ") && (lower.length > sel.length + 1) && (lower.charCodeAt(sel.length + 1) >= 48) && (lower.charCodeAt(sel.length + 1) <= 57));
+            });
+        });
+        countLabel = "uncovered (" + String(filteredChannels.length) + " of " + String(availableChannels.length) + ")";
     }
     else {
-        // Target sorts between two anchors.
-        lowerDomIndex = anchors[insertBeforeIndex - 1].domIndex;
-        upperDomIndex = anchors[insertBeforeIndex].domIndex;
-    }
-    // Find call sign channels in the DOM range between the two anchors.
-    for (const ch of rendered) {
-        if ((ch.domIndex > lowerDomIndex) && (ch.domIndex < upperDomIndex) && CALL_SIGN_PATTERN.test(ch.name)) {
-            return ch.name;
-        }
-    }
-    return null;
-}
-/**
- * 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
- * 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 WLS 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)
- * 2. Wait for the channel grid rows to render in the DOM
- * 3. Check the row number cache for a direct-scroll shortcut
- * 4. Binary search: scroll to the midpoint row, read rendered channels (caching row numbers), check for exact match or infer local affiliate
- * 5. If binary search fails, linear scan from top to bottom as a universal fallback
- * 6. Click the on-now program cell (`.LiveGuideProgram--first`) in the target channel's row to open the playback overlay
- * 7. If playSelector is provided, wait for and click the play button to start live playback
- * @param page - The Puppeteer page object.
- * @param channelName - The channel name to match against data-testid attributes (case-insensitive).
- * @param channelSelection - The channel selection configuration containing strategy, listSelector, and playSelector.
- * @returns Result object with success status and optional failure reason.
- */
-async function guideGridStrategy(page, channelName, channelSelection) {
-    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
-    // 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) {
-        try {
-            await page.waitForSelector(listSelector, { timeout: CONFIG.streaming.videoTimeout, visible: true });
-            await page.$eval(listSelector, (el) => el.click());
-            // Brief delay for the tab switch animation and virtualizer initialization.
-            await delay(300);
-        }
-        catch (error) {
-            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
-    // 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++) {
-        try {
-            const rowTimeout = (guideAttempt === 0) ? 5000 : CONFIG.streaming.videoTimeout;
-            // eslint-disable-next-line no-await-in-loop
-            await page.waitForSelector("[data-testid=\"live-guide-row\"]", { timeout: rowTimeout, visible: true });
-            rowsVisible = true;
-            break;
-        }
-        catch {
-            // Rows not visible yet. On first failure, retry the tab click in case the guide wasn't fully interactive.
-            if ((guideAttempt === 0) && listSelector) {
-                LOG.debug("Guide rows not visible after initial wait. Retrying tab click for %s.", listSelector);
-                try {
-                    // eslint-disable-next-line no-await-in-loop
-                    await page.$eval(listSelector, (el) => el.click());
-                    // eslint-disable-next-line no-await-in-loop
-                    await delay(500);
-                }
-                catch {
-                    // Retry click failed. Fall through to final wait attempt.
-                }
-            }
-        }
-    }
-    if (!rowsVisible) {
-        return { reason: "Channel grid rows did not render.", success: false };
-    }
-    // Each row in the virtualized grid is exactly 112px tall. The total number of channels is derived from the spacer div's height.
-    const ROW_HEIGHT = 112;
-    // Normalize the channel name to lowercase for case-insensitive matching against data-testid suffixes.
-    const normalizedName = normalizeChannelName(channelName);
-    // Read grid metadata by walking up from a rendered row to find the spacer and viewport divs. The spacer div is the direct parent of all absolutely-positioned
-    // rows, and its height equals totalRows * ROW_HEIGHT. The viewport div is the spacer's parent (overflow: hidden). We calculate gridDocTop as the viewport's
-    // document-level offset, so that scrolling to gridDocTop + (rowIndex * ROW_HEIGHT) places that row at the top of the browser viewport.
-    const gridMeta = await page.evaluate((rowHeight) => {
-        const row = document.querySelector("[data-testid=\"live-guide-row\"]");
-        if (!row) {
-            return null;
-        }
-        // The spacer div is the parent of all row elements.
-        const spacer = row.parentElement;
-        if (!spacer) {
-            return null;
-        }
-        const spacerHeight = spacer.offsetHeight;
-        if (spacerHeight < rowHeight) {
-            return null;
-        }
-        // The viewport div is the spacer's parent. Its position relative to the document determines our scroll offset.
-        const viewport = spacer.parentElement;
-        if (!viewport) {
-            return null;
-        }
-        const gridDocTop = viewport.getBoundingClientRect().top + document.documentElement.scrollTop;
-        return { gridDocTop, totalRows: Math.round(spacerHeight / rowHeight) };
-    }, ROW_HEIGHT);
-    if (!gridMeta) {
-        return { reason: "Could not locate channel grid spacer element.", success: false };
-    }
-    const { gridDocTop, totalRows } = gridMeta;
-    // Helper: scroll to a specific row index and wait for the virtualizer to render.
-    const scrollToRow = async (rowIndex) => {
-        await page.evaluate((scrollTo) => {
-            document.documentElement.scrollTop = scrollTo;
-        }, gridDocTop + (rowIndex * ROW_HEIGHT));
-        await delay(200);
-    };
-    // The name of the channel to click. This starts as the normalized target name but may be replaced by a local affiliate call sign via position inference.
-    let clickTarget = normalizedName;
-    // Check the row number cache for a direct-scroll shortcut. If we've seen this channel before, we can skip binary search entirely and scroll directly to it.
-    const cachedRow = guideRowCache.get(normalizedName);
-    if (cachedRow !== undefined) {
-        LOG.debug("Guide cache hit for %s at row %s.", channelName, cachedRow);
-        await scrollToRow(cachedRow);
-        // Read rendered channels to update the cache and confirm the channel is present.
-        const rendered = await readRenderedChannels(page);
-        if (rendered) {
-            const match = rendered.find((ch) => ch.name === normalizedName);
-            if (match) {
-                return await clickOnNowCellAndPlay(page, normalizedName, playSelector, channelName);
-            }
-        }
-        // Cache hit but channel not found at expected position. The guide may have changed. Clear this entry and fall through to binary search.
-        LOG.debug("Guide cache miss for %s. Falling back to binary search.", channelName);
-        guideRowCache.delete(normalizedName);
-    }
-    // Binary search through the virtualized channel list. On each iteration we scroll to the midpoint of the current range, wait for the virtualizer to render,
-    // then check if the target channel is among the ~13 rendered rows. If not, we compare the target name alphabetically against the first and last rendered
-    // channel names to narrow the range. The search converges in ~3-4 iterations because the 13-row render window covers a large fraction of the remaining range.
-    let low = 0;
-    let high = totalRows - 1;
-    const maxIterations = 10;
-    let found = false;
-    for (let iteration = 0; iteration < maxIterations; iteration++) {
-        if (low > high) {
-            break;
-        }
-        const mid = Math.floor((low + high) / 2);
-        // eslint-disable-next-line no-await-in-loop
-        await scrollToRow(mid);
-        // Read all rendered channels, populating the row number cache as a side effect.
-        // eslint-disable-next-line no-await-in-loop
-        const rendered = await readRenderedChannels(page);
-        if (!rendered || (rendered.length === 0)) {
-            continue;
-        }
-        // Check for an exact match first.
-        const exactMatch = rendered.find((ch) => ch.name === normalizedName);
-        if (exactMatch) {
-            found = true;
-            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
-        // localeCompare would send the search the wrong way.
-        const nonCallSigns = rendered.filter((ch) => !CALL_SIGN_PATTERN.test(ch.name));
-        if (nonCallSigns.length === 0) {
-            // All rendered channels are call signs. Cannot determine direction. Move down and hope for better data.
-            low = mid + 1;
-            continue;
-        }
-        const first = nonCallSigns[0].name;
-        const last = nonCallSigns[nonCallSigns.length - 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;
-            continue;
-        }
-        if (normalizedName.localeCompare(last) > 0) {
-            // Target sorts after the last visible non-call-sign channel. Scroll down (toward higher row indices).
-            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
-        // 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) {
-            LOG.info("Inferred local affiliate %s for network name %s.", inferred, channelName);
-            clickTarget = inferred;
-            found = true;
-            // Cache the network name → affiliate's row number so subsequent tunes for the same network name become direct scrolls.
-            const inferredRow = guideRowCache.get(inferred);
-            if (inferredRow !== undefined) {
-                guideRowCache.set(normalizedName, inferredRow);
-            }
-        }
-        break;
-    }
-    // If binary search did not find the channel (and position inference didn't identify a local affiliate), fall back to a linear scan through all channels. This
-    // handles edge cases like raw call sign searches (e.g., "WLS") where localeCompare gives the wrong direction, or channels like "Lakeshore PBS" that sort by
-    // hidden network name but don't match the W/K call sign pattern.
-    if (!found) {
-        LOG.debug("Binary search did not find %s. Starting linear scan fallback.", channelName);
-        for (let row = 0; row < totalRows; row += 10) {
-            // eslint-disable-next-line no-await-in-loop
-            await scrollToRow(row);
-            // eslint-disable-next-line no-await-in-loop
-            const rendered = await readRenderedChannels(page);
-            if (!rendered) {
-                continue;
-            }
-            const match = rendered.find((ch) => ch.name === normalizedName);
-            if (match) {
-                found = true;
-                break;
-            }
-        }
-    }
-    if (!found) {
-        return { reason: "Could not find channel " + channelName + " in guide grid.", success: false };
-    }
-    // Click the on-now program cell and wait for the play button, with click retries to handle React hydration timing.
-    return await clickOnNowCellAndPlay(page, clickTarget, playSelector, channelName);
-}
-/**
- * Waits for the play button to appear and clicks it using coordinate-based mouse events. Called by clickOnNowCellAndPlay after each on-now cell click attempt.
- * @param page - The Puppeteer page object.
- * @param playSelector - The CSS selector for the play button, or undefined if no play button is needed.
- * @param timeout - Optional timeout in milliseconds for the play button to appear. Defaults to CONFIG.streaming.videoTimeout.
- * @returns Result object with success status and optional failure reason.
- */
-async function waitForPlayButton(page, playSelector, timeout) {
-    if (!playSelector) {
-        return { success: true };
-    }
-    try {
-        await page.waitForSelector(playSelector, { timeout: timeout ?? CONFIG.streaming.videoTimeout, visible: true });
-        // Wait two animation frames for React to flush pending state updates. The play button may be visible in the DOM before React's concurrent mode has committed
-        // the channel selection state to the component's event handlers. Without this, clicking immediately can trigger playback of the previously-selected channel
-        // rather than the one we just chose. The double-rAF pattern synchronizes with the browser's rendering pipeline rather than using a fixed delay.
-        await page.evaluate(async () => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))));
-        // Get the play button's coordinates for a real mouse click. Like the on-now cell click, we use page.mouse.click() to generate the full pointer event chain
-        // rather than a bare DOM .click().
-        const playTarget = await evaluateWithAbort(page, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) {
-                return null;
-            }
-            el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-            const rect = el.getBoundingClientRect();
-            if ((rect.width > 0) && (rect.height > 0)) {
-                return { x: rect.x + (rect.width / 2), y: rect.y + (rect.height / 2) };
-            }
-            return null;
-        }, [playSelector]);
-        if (!playTarget) {
-            return { reason: "Play selector " + playSelector + " found but has no dimensions.", success: false };
-        }
-        await scrollAndClick(page, playTarget);
-        return { success: true };
+        // No preset suffix — log all available channels unfiltered. Used for small channel sets (Fox, HBO) where the full list is actionable without filtering.
+        filteredChannels = availableChannels;
+        countLabel = String(filteredChannels.length);
     }
-    catch (error) {
-        return { reason: "Could not click play selector " + playSelector + ": " + formatError(error) + ".", success: false };
-    }
-}
-/**
- * Clicks the on-now program cell and waits for the play button, retrying the click if the play button doesn't appear. This handles a timing issue where the
- * guide grid's DOM elements render (so binary search finds the channel) before React has fully hydrated the event handlers (so the first mouse click on the
- * on-now cell may not trigger the playback overlay). Retrying the click after a brief delay allows hydration to complete.
- * @param page - The Puppeteer page object.
- * @param clickTarget - The lowercased, trimmed channel name to locate in the guide grid.
- * @param playSelector - The CSS selector for the play button, or undefined if no play button is needed.
- * @param channelName - The original channel name for logging.
- * @returns Result object with success status and optional failure reason.
- */
-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
-    // 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.
-    const CLICK_RETRY_DELAY = 1500;
-    for (let attempt = 0; attempt < MAX_CLICK_ATTEMPTS; attempt++) {
-        // eslint-disable-next-line no-await-in-loop
-        const onNowTarget = await locateOnNowCell(page, clickTarget);
-        if (!onNowTarget) {
-            return { reason: "Found channel " + channelName + " but could not locate on-now program cell.", success: false };
-        }
-        // eslint-disable-next-line no-await-in-loop
-        await scrollAndClick(page, onNowTarget);
-        // Use a shorter timeout on non-final attempts to enable quick retries. The final attempt uses the full default timeout as a last chance.
-        const playTimeout = (attempt < MAX_CLICK_ATTEMPTS - 1) ? RETRY_PLAY_TIMEOUT : undefined;
-        // eslint-disable-next-line no-await-in-loop
-        const result = await waitForPlayButton(page, playSelector, playTimeout);
-        if (result.success) {
-            return result;
-        }
-        // Play button didn't appear — the click likely didn't register. Retry after a brief delay.
-        if (attempt < MAX_CLICK_ATTEMPTS - 1) {
-            LOG.debug("Play button did not appear for %s. Retrying on-now cell click (attempt %s of %s).", channelName, attempt + 2, MAX_CLICK_ATTEMPTS);
-            // eslint-disable-next-line no-await-in-loop
-            await delay(CLICK_RETRY_DELAY);
-        }
+    if (filteredChannels.length === 0) {
+        return;
     }
-    return { reason: "Play button did not appear after " + MAX_CLICK_ATTEMPTS + " on-now cell click attempts for " + channelName + ".", success: false };
+    LOG.warn("Channel \"%s\" not found in %s guide. Create a user-defined channel with one of the names below as the Channel Selector and %s as the URL. " +
+        "Available channels (%s): %s.", channelName, providerName, guideUrl, countLabel, filteredChannels.join(", "));
 }
-/* The selectChannel() function is the public API for channel selection. It delegates to the appropriate strategy based on the profile configuration.
- */
 /**
  * Selects a channel from a multi-channel player UI using the strategy specified in the profile. This is the main entry point for channel selection, called by
  * tuneToChannel() after page navigation.
@@ -983,57 +122,35 @@ async function clickOnNowCellAndPlay(page, clickTarget, playSelector, channelNam
  * @returns Result object with success status and optional failure reason.
  */
 export async function selectChannel(page, profile) {
-    const { channelSelection, channelSelector } = profile;
+    const { channelSelection } = profile;
     // No channel selection needed if strategy is "none" or no channelSelector is specified.
-    if ((channelSelection.strategy === "none") || !channelSelector) {
+    if ((channelSelection.strategy === "none") || !isChannelSelectionProfile(profile)) {
         return { success: true };
     }
     // Poll for the channel slug image to appear and fully load. We check both src match and load completion (img.complete + naturalWidth) to ensure the image is
     // actually rendered before proceeding. This prevents race conditions where the img element exists with the correct src but the browser hasn't finished fetching
-    // and rendering it, which can cause layout instability and click failures. We skip this polling for guideGrid (channel list images are hidden behind a tab),
-    // hboGrid (channelSelector is a channel name, not an image URL slug), and youtubeGrid (same reason as hboGrid).
-    if ((channelSelection.strategy !== "guideGrid") && (channelSelection.strategy !== "hboGrid") && (channelSelection.strategy !== "youtubeGrid")) {
+    // and rendering it, which can cause layout instability and click failures. We skip this polling for foxGrid (channelSelector is a station code, not an image
+    // URL slug), guideGrid (channel list images are hidden behind a tab), hboGrid (channelSelector is a channel name, not an image URL slug), slingGrid (same
+    // reason as hboGrid), and youtubeGrid (same reason as hboGrid).
+    const skipImagePolling = ["foxGrid", "guideGrid", "hboGrid", "slingGrid", "youtubeGrid"];
+    if (!skipImagePolling.includes(channelSelection.strategy)) {
         try {
             await page.waitForFunction((slug) => {
                 return Array.from(document.querySelectorAll("img")).some((img) => img.src && img.src.includes(slug) && img.complete && (img.naturalWidth > 0));
-            }, { timeout: CONFIG.playback.channelSelectorDelay }, channelSelector);
+            }, { timeout: CONFIG.playback.channelSelectorDelay }, profile.channelSelector);
         }
         catch {
             // Timeout — the image hasn't loaded yet. Proceed anyway and let the strategy evaluate and report not-found naturally.
         }
     }
-    // Dispatch to the appropriate strategy.
-    let result;
-    switch (channelSelection.strategy) {
-        case "guideGrid": {
-            result = await guideGridStrategy(page, channelSelector, channelSelection);
-            break;
-        }
-        case "hboGrid": {
-            result = await hboGridStrategy(page, channelSelector);
-            break;
-        }
-        case "thumbnailRow": {
-            result = await thumbnailRowStrategy(page, channelSelector);
-            break;
-        }
-        case "tileClick": {
-            result = await tileClickStrategy(page, channelSelector);
-            break;
-        }
-        case "youtubeGrid": {
-            result = await youtubeGridStrategy(page, channelSelector);
-            break;
-        }
-        default: {
-            // Unknown strategy - this shouldn't happen if profiles are validated, but handle gracefully.
-            LOG.warn("Unknown channel selection strategy: %s.", channelSelection.strategy);
-            return { reason: "Unknown channel selection strategy.", success: false };
-        }
-    }
-    if (!result.success) {
-        LOG.warn("Failed to select %s from channel guide: %s", channelSelector, result.reason ?? "Unknown reason.");
+    // Dispatch to the appropriate strategy via the registry.
+    const strategyFn = strategies[channelSelection.strategy];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!strategyFn) {
+        LOG.warn("Unknown channel selection strategy: %s.", channelSelection.strategy);
+        return { reason: "Unknown channel selection strategy.", success: false };
     }
+    const result = await strategyFn(page, profile);
     return result;
 }
 //# sourceMappingURL=channelSelection.js.map