prismcast 1.12.1 → 1.14.0

package/dist/browser/navigation.js

@@ -0,0 +1,57 @@
+import { CONFIG } from "../config/index.js";
+import { LOG } from "../utils/index.js";
+/**
+ * Puts the page on the given URL and waits for it the way the options ask. Under the network-idle wait, the load returns once network activity settles, allowing
+ * up to two concurrent connections for 500 ms, which is what gives a complex JavaScript player time to finish initializing; the wait also carries the navigation
+ * timeout, and a timeout under it is tolerated rather than thrown, because the video frequently has loaded even when some background request never completed.
+ * Without the network-idle wait the load returns as soon as the page fires its load event, which is the only workable answer for a site whose persistent
+ * connections or continuous polling would keep it from ever reaching idle, and a failure there propagates.
+ * @param page - The Puppeteer page object.
+ * @param url - The URL to load.
+ * @param options - The wait preference for this load.
+ * @returns The document response, or null when the network-idle wait timed out and the page was left as it loaded.
+ */
+export async function loadDocument(page, url, options) {
+    if (options.waitForNetworkIdle) {
+        try {
+            // Wait for network activity to settle. This ensures complex JavaScript players have fully initialized. The networkidle2 strategy allows up to 2
+            // concurrent requests, which handles sites with persistent connections for analytics.
+            return await page.goto(url, { timeout: CONFIG.streaming.navigationTimeout, waitUntil: "networkidle2" });
+        }
+        catch (error) {
+            // Timeout errors during navigation are common and often non-fatal - the video may have loaded successfully even if some background requests never
+            // completed. We log a warning and continue rather than throwing.
+            if (error && (error.name === "TimeoutError")) {
+                LOG.warn("Page navigation timed out after %sms for %s.", CONFIG.streaming.navigationTimeout, url);
+                return null;
+            }
+            // Non-timeout errors (network failure, invalid URL, etc.) should be propagated for retry handling.
+            throw error;
+        }
+    }
+    // Simple navigation without waiting for network idle. Returns after the load event fires. Used for sites that would never reach networkidle due to
+    // persistent connections, streaming data, or continuous polling.
+    return page.goto(url);
+}
+/**
+ * Reloads the page it is handed, mirroring loadDocument's wait strategy and its timeout tolerance so a reload and a fresh load of the same site behave the same
+ * way. A reload timeout is often non-fatal - the player may already be present even if some background requests never settled - so it warns and continues, and
+ * every other error propagates.
+ * @param page - The Puppeteer page object.
+ * @param options - The wait preference for this reload.
+ */
+export async function reloadDocument(page, options) {
+    const waitUntil = options.waitForNetworkIdle ? "networkidle2" : "load";
+    try {
+        await page.reload({ timeout: CONFIG.streaming.navigationTimeout, waitUntil });
+    }
+    catch (error) {
+        if (error && (error.name === "TimeoutError")) {
+            LOG.warn("Page reload timed out after %sms.", CONFIG.streaming.navigationTimeout);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=navigation.js.map

package/dist/browser/navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../../src/browser/navigation.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAqBxC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,IAAU,EAAE,GAAW,EAAE,OAA4B;IAEtF,IAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAE9B,IAAI,CAAC;YAEH,gJAAgJ;YAChJ,sFAAsF;YACtF,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC,CAAC;QAC1G,CAAC;QAAC,OAAM,KAAK,EAAE,CAAC;YAEd,kJAAkJ;YAClJ,iEAAiE;YACjE,IAAG,KAAK,IAAI,CAAE,KAAe,CAAC,IAAI,KAAK,cAAc,CAAC,EAAE,CAAC;gBAEvD,GAAG,CAAC,IAAI,CAAC,8CAA8C,EAAE,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;gBAElG,OAAO,IAAI,CAAC;YACd,CAAC;YAED,mGAAmG;YACnG,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,mJAAmJ;IACnJ,iEAAiE;IACjE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACxB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,IAAU,EAAE,OAA4B;IAE3E,MAAM,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC;IAEvE,IAAI,CAAC;QAEH,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE,SAAS,EAAE,CAAC,CAAC;IAChF,CAAC;IAAC,OAAM,KAAK,EAAE,CAAC;QAEd,IAAG,KAAK,IAAI,CAAE,KAAe,CAAC,IAAI,KAAK,cAAc,CAAC,EAAE,CAAC;YAEvD,GAAG,CAAC,IAAI,CAAC,mCAAmC,EAAE,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QACpF,CAAC;aAAM,CAAC;YAEN,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/browser/pageStaleness.d.ts

@@ -27,4 +27,3 @@ export interface StalePageActions {
  * @returns The clocks to start, the marks to clear, the entries to forget, and the pages to close.
  */
 export declare function evaluateStalePages(snapshot: StalePageSnapshot): StalePageActions;
-//# sourceMappingURL=pageStaleness.d.ts.map

package/dist/browser/precaching.d.ts

@@ -1,8 +1,10 @@
-import type { DiscoveredChannel, ProviderModule } from "../types/index.ts";
-import { createDiscoveryPage, emulateLayoutSurface, getCurrentBrowser, isGracefulShutdown, registerManagedPage, syncWindowVisibility, unregisterManagedPage } from "./index.ts";
+import type { ChangeRejection, ConfigChange } from "../config/reactivity.ts";
+import type { Config, DiscoveredChannel, ProviderModule } from "../types/index.ts";
+import { createDiscoveryPage, emulateLayoutSurface, getCurrentBrowser, isBrowserConnected, isGracefulShutdown, registerManagedPage, syncWindowVisibility, unregisterManagedPage } from "./index.ts";
 import { getPersistedLineup, persistProviderLineup } from "../config/providerLineups.ts";
 import { getProviderBySlug, getProvidersForDomain } from "./channelSelection.ts";
 import type { BlockedPageClassification } from "./blockedPage.ts";
+import type { Clock } from "homebridge-plugin-utils";
 import type { Page } from "puppeteer-core";
 import { startOverlayHandling } from "./consent.ts";
 /**
@@ -13,12 +15,14 @@ export declare class DiscoveryWalkTimeoutError extends Error {
     constructor(label: string, timeoutMs: number);
 }
 export interface PrecachingDeps {
+    readonly clock: Clock;
     readonly createDiscoveryPage: typeof createDiscoveryPage;
     readonly emulateLayoutSurface: typeof emulateLayoutSurface;
     readonly getCurrentBrowser: typeof getCurrentBrowser;
     readonly getPersistedLineup: typeof getPersistedLineup;
     readonly getProviderBySlug: typeof getProviderBySlug;
     readonly getProvidersForDomain: typeof getProvidersForDomain;
+    readonly isBrowserConnected: typeof isBrowserConnected;
     readonly isGracefulShutdown: typeof isGracefulShutdown;
     readonly persistProviderLineup: typeof persistProviderLineup;
     readonly registerManagedPage: typeof registerManagedPage;
@@ -28,19 +32,32 @@ export interface PrecachingDeps {
 }
 export declare const defaultPrecachingDeps: PrecachingDeps;
 /**
- * Starts the precaching cycle if services are configured. Called from launchBrowser() after the browser is ready. If no services are selected, a shutdown is in
- * progress, or a precache cycle is already in progress, returns immediately. The actual work is scheduled via setTimeout to avoid blocking browser launch.
+ * Requests a precache cycle over every listed service. This is the browser launch's request, made once its browser is ready, because a launched browser starts
+ * with every provider cache empty; a save requests only the services it adds, through applyPrecacheConfigChanges. Returns at once when no service is listed, and
+ * otherwise lands the request through requestPrecache, whose cycle waits out the settle delay on the dependencies' clock, so the launch is never blocked.
  * @param deps - The injected browser and provider-registry dependencies; defaults to defaultPrecachingDeps.
  */
 export declare function startPrecaching(deps?: PrecachingDeps): void;
 /**
- * Cancels every scheduled precache - the startup cycle and the deferred re-attempt alike - and clears the in-progress guard. Called during graceful shutdown so
- * nothing scheduled can fire after the browser has been closed. Safe to call when nothing is pending.
+ * Cancels every scheduled precache - the pending cycle and the deferred re-attempt alike - drops a recorded request, and clears the in-progress guard. Called
+ * during graceful shutdown so nothing scheduled can fire after the browser has been closed. Safe to call when nothing is pending.
  *
- * The guard is cleared directly rather than through releasePrecacheGuard, and the hand-off flag with it: a shutdown must not honor a pending full-cycle request,
- * which is exactly what releasing through the hand-off would do.
+ * The slots are cleared through updateSchedule, which disposes their timers. The guard is cleared directly rather than through releasePrecacheGuard, and the
+ * recorded request with it: a shutdown must not hand on a pending request, which is exactly what releasing through the hand-off would do.
  */
 export declare function stopPrecaching(): void;
+/**
+ * Requests a walk of the services a saved precache list adds. The candidate carries the saved list and CONFIG still holds the running one, because the reconcile
+ * commits only after its handlers run, so the services the save adds are the candidate's slugs the running list lacks. They are requested as one scope while a
+ * browser is connected, so the save precaches them without clearing any other provider's cache. A save that only removes services needs nothing here, because
+ * every reader of the list reads it when it walks, and with no browser running the save requests nothing, because a browser is never launched for a save and
+ * the next launch requests every listed service. Requesting cannot fail, so the handler refuses nothing.
+ * @param _changes - The change to the precache list; the candidate carries the list, so the handler reads that instead.
+ * @param next - The candidate running configuration.
+ * @param deps - The injected dependencies; defaults to defaultPrecachingDeps.
+ * @returns No rejections.
+ */
+export declare function applyPrecacheConfigChanges(_changes: readonly ConfigChange[], next: Readonly<Config>, deps?: PrecachingDeps): Promise<readonly ChangeRejection[]>;
 /**
  * Records the consequences of a completed channel discovery: the domain auth state it proves, and the durable lineup it produced. This is the single source of
  * truth for discovery-outcome policy, consumed by both the precache cycle (via precacheService) and the /services/:slug/channels endpoint - the routes layer never
@@ -99,11 +116,10 @@ export declare function precacheService(provider: ProviderModule, deps?: Precach
  *
  * Never rejects - the observer wiring voids the returned promise, so every failure is logged and absorbed here. Revalidation deliberately ignores both the
  * precacheServices and enabledServices filters: this is clearing-evidence collection for a domain the user just signed in to, not precaching, and the cycle's
- * filter skip is unchanged. While it runs it holds the same single-flight guard the precache cycle holds, so a cycle scheduled mid-revalidation (a browser crash
- * relaunch) defers instead of overlapping.
+ * filter skip is unchanged. While it runs it holds the same single-flight guard the precache cycle holds, so a cycle requested mid-revalidation, by a launch or
+ * a save, is recorded and armed once the revalidation releases the guard, instead of overlapping it.
  * @param url - The login session's URL; its extracted domain selects the providers to revalidate.
  * @returns A promise that resolves when revalidation completes or is skipped. It never rejects.
  */
 export declare function revalidateDomainAuth(url: string, deps?: PrecachingDeps): Promise<void>;
 export {};
-//# sourceMappingURL=precaching.d.ts.map