prismcast 1.5.2 → 1.7.0

package/dist/native/proxy.js

@@ -0,0 +1,947 @@
+/* Copyright(C) 2024-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * proxy.ts: Native HLS proxy — manifest polling, segment fetching, and playlist generation.
+ */
+import { LOG, chromeFetch, startTimer } from "../utils/index.js";
+import { buildPrerollEntries, computePrerollWindow } from "../streaming/preroll.js";
+import { decryptSegment, deriveIvFromSequence, fetchDecryptionKey, parseExplicitIv } from "./decrypt.js";
+import { storeAudioSegment, storeSegment, updateAudioPlaylist, updatePlaylist, updateVideoPlaylist } from "../streaming/hlsSegments.js";
+import { CONFIG } from "../config/index.js";
+import { buildPlaylist } from "../streaming/playlistBuilder.js";
+import { getStream } from "../streaming/registry.js";
+import { removeManifestInterceptor } from "./intercept.js";
+import { resolveUrl } from "./probe.js";
+/* This module implements the native HLS proxy that replaces Chrome screen capture for viable streams. It polls the provider's variant manifest at regular intervals,
+ * detects new segments by tracking #EXT-X-MEDIA-SEQUENCE, fetches each segment (optionally decrypting AES-128), stores them in the existing HLS segment system, and
+ * generates an HLS playlist that faithfully propagates upstream metadata — discontinuity markers, program timestamps, and SCTE-35 ad signaling (cue-out, cue-in,
+ * cue-out-cont).
+ *
+ * The proxy generates its own playlist rather than rewriting the provider's playlist, which avoids dealing with CDN-relative URLs and provider-specific quirks. However,
+ * it preserves all playback-critical tags from the upstream manifest so that downstream consumers (Channels DVR) can correctly handle PTS resets at ad boundaries,
+ * synchronize wall-clock time, and detect commercial breaks.
+ *
+ * Video segments are stored as "segment0.ts", "segment1.ts", etc. For streams with separate audio renditions, audio segments are stored as "audio0.ts",
+ * "audio1.ts", etc.
+ */
+// Timeout for segment fetches.
+const SEGMENT_FETCH_TIMEOUT = 10000;
+// Maximum consecutive manifest poll failures before reporting an error. Client errors (4xx) use this threshold directly. Server errors (5xx) and network timeouts
+// use double the threshold to tolerate transient CDN issues that typically self-resolve within a few retry cycles.
+const MAX_MANIFEST_FAILURES = 3;
+// Maximum consecutive segment fetch failures before reporting an error.
+const MAX_SEGMENT_FAILURES = 5;
+// Manifest poll backoff base delay and cap. On success, the poll interval returns to the base delay (half the target duration, typically ~3s). On failure, the delay
+// doubles on each consecutive failure up to the cap. Jitter of +/-20% prevents multiple streams from retrying in lockstep after a shared CDN outage.
+const MANIFEST_BACKOFF_BASE = 3000;
+const MANIFEST_BACKOFF_CAP = 15000;
+// Manifest Parsing Helpers.
+/**
+ * Parses a variant manifest into its metadata and segment list. Handles #EXT-X-MEDIA-SEQUENCE, #EXT-X-TARGETDURATION, #EXT-X-KEY (AES-128 with key rotation),
+ * #EXT-X-DISCONTINUITY, #EXT-X-PROGRAM-DATE-TIME, #EXT-X-CUE-OUT, #EXT-X-CUE-OUT-CONT, #EXT-X-CUE-IN, and #EXTINF + segment URL pairs. Key/IV state and metadata
+ * flags are tracked per-segment so key rotation and discontinuities within a single manifest are handled correctly.
+ *
+ * @param body - The variant manifest text content.
+ * @param baseUrl - Base URL for resolving relative segment and key URLs.
+ * @returns Parsed metadata and segment list.
+ */
+function parseVariantManifest(body, baseUrl) {
+    const lines = body.split("\n");
+    // Parse header tags: #EXT-X-MEDIA-SEQUENCE and #EXT-X-TARGETDURATION. The upstream #EXT-X-DISCONTINUITY-SEQUENCE is intentionally ignored — the proxy computes its
+    // own value from its local sliding window, which differs from the upstream's window size and rotation rate.
+    let mediaSequence = 0;
+    let targetDuration = 6;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#EXT-X-MEDIA-SEQUENCE:")) {
+            mediaSequence = Number(trimmed.split(":")[1]);
+        }
+        else if (trimmed.startsWith("#EXT-X-TARGETDURATION:")) {
+            targetDuration = Number(trimmed.split(":")[1]);
+        }
+    }
+    // Parse segments: each #EXTINF line is followed by the segment URL. Per the HLS spec, each #EXT-X-KEY applies to all subsequent segments until the next
+    // #EXT-X-KEY tag. We track the current key URL and IV per segment so key rotation within a single manifest is handled correctly. Metadata tags
+    // (#EXT-X-DISCONTINUITY, #EXT-X-PROGRAM-DATE-TIME, #EXT-X-CUE-OUT, #EXT-X-CUE-IN, #EXT-X-CUE-OUT-CONT) are accumulated as pending flags and attached to the
+    // next segment.
+    const segments = [];
+    let currentSequence = mediaSequence;
+    let currentManifestKeyUrl = null;
+    let currentIvHex = null;
+    // Pending metadata flags — accumulated from tags between segments and attached to the next #EXTINF.
+    let pendingCueIn = false;
+    let pendingCueOut = null;
+    let pendingCueOutCont = null;
+    let pendingDiscontinuity = false;
+    let pendingProgramDateTime = null;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("#EXT-X-KEY:")) {
+            const methodMatch = /METHOD=([A-Za-z0-9-]+)/.exec(trimmed);
+            const method = methodMatch ? methodMatch[1].toUpperCase() : "NONE";
+            if (method === "AES-128") {
+                const uriMatch = /URI="([^"]+)"/.exec(trimmed);
+                if (uriMatch) {
+                    currentManifestKeyUrl = resolveUrl(uriMatch[1], baseUrl);
+                }
+                const ivMatch = /IV=([0-9a-fA-Fx]+)/.exec(trimmed);
+                currentIvHex = ivMatch ? ivMatch[1] : null;
+            }
+            else if (method === "NONE") {
+                currentManifestKeyUrl = null;
+                currentIvHex = null;
+            }
+            continue;
+        }
+        if (trimmed === "#EXT-X-DISCONTINUITY") {
+            pendingDiscontinuity = true;
+            continue;
+        }
+        if (trimmed.startsWith("#EXT-X-PROGRAM-DATE-TIME:")) {
+            pendingProgramDateTime = trimmed.slice(25);
+            continue;
+        }
+        if (trimmed.startsWith("#EXT-X-CUE-OUT-CONT:")) {
+            pendingCueOutCont = trimmed.slice(20);
+            continue;
+        }
+        if (trimmed.startsWith("#EXT-X-CUE-OUT:")) {
+            pendingCueOut = trimmed.slice(15);
+            continue;
+        }
+        if (trimmed === "#EXT-X-CUE-OUT") {
+            pendingCueOut = "";
+            continue;
+        }
+        if (trimmed === "#EXT-X-CUE-IN") {
+            pendingCueIn = true;
+            continue;
+        }
+        if (!trimmed.startsWith("#EXTINF:")) {
+            continue;
+        }
+        const durationStr = trimmed.slice(8).split(",")[0];
+        const duration = Number(durationStr);
+        const segUrl = (i + 1 < lines.length) ? lines[i + 1].trim() : "";
+        if (!segUrl || segUrl.startsWith("#")) {
+            currentSequence++;
+            continue;
+        }
+        segments.push({
+            cueIn: pendingCueIn,
+            cueOut: pendingCueOut,
+            cueOutCont: pendingCueOutCont,
+            discontinuity: pendingDiscontinuity,
+            duration,
+            ivHex: currentIvHex,
+            keyUrl: currentManifestKeyUrl,
+            programDateTime: pendingProgramDateTime,
+            sequence: currentSequence,
+            url: resolveUrl(segUrl, baseUrl)
+        });
+        // Reset pending flags after attaching them to a segment.
+        pendingCueIn = false;
+        pendingCueOut = null;
+        pendingCueOutCont = null;
+        pendingDiscontinuity = false;
+        pendingProgramDateTime = null;
+        currentSequence++;
+    }
+    return { mediaSequence, segments, targetDuration };
+}
+/**
+ * Builds a variant playlist string from stored segment filenames and their associated metadata. Emits #EXT-X-DISCONTINUITY, #EXT-X-DISCONTINUITY-SEQUENCE,
+ * #EXT-X-PROGRAM-DATE-TIME, #EXT-X-CUE-OUT, #EXT-X-CUE-OUT-CONT, and #EXT-X-CUE-IN tags to faithfully represent upstream ad boundaries and PTS resets.
+ *
+ * @param segmentEntries - Ordered list of segment filenames from the segment Map.
+ * @param metadata - Per-segment metadata (durations, timestamps, discontinuities, cue markers).
+ * @param prefix - Filename prefix for extracting the sequence index (e.g., "segment" or "audio").
+ * @param targetDuration - #EXT-X-TARGETDURATION value.
+ * @returns The formatted m3u8 playlist string.
+ */
+function buildVariantPlaylist(segmentEntries, metadata, prefix, targetDuration) {
+    // Compute MEDIA-SEQUENCE from the first filename in the window. The filename encodes the local segment index (e.g., "segment5.ts" → 5).
+    let mediaSequence = 0;
+    if (segmentEntries.length > 0) {
+        mediaSequence = Number(segmentEntries[0].replace(prefix, "").replace(".ts", ""));
+    }
+    // Compute DISCONTINUITY-SEQUENCE: total discontinuities ever observed minus those still visible in the current window. Only provided when > 0 to keep playlists
+    // clean for streams that never have discontinuities.
+    let windowDiscontinuities = 0;
+    for (const filename of segmentEntries) {
+        if (metadata.discontinuities.has(filename)) {
+            windowDiscontinuities++;
+        }
+    }
+    const discSeq = metadata.totalDiscontinuities - windowDiscontinuities;
+    const discontinuitySequence = (discSeq > 0) ? discSeq : undefined;
+    const entries = segmentEntries.map((filename) => buildEntryFromMetadata(filename, metadata, targetDuration));
+    return buildPlaylist({ discontinuitySequence, mediaSequence, targetDuration, version: 3 }, entries);
+}
+/**
+ * Creates an empty SegmentMetadata instance with fresh Maps and a zeroed discontinuity counter.
+ * @returns A new SegmentMetadata instance.
+ */
+function createSegmentMetadata() {
+    return {
+        cueIns: new Map(),
+        cueOutConts: new Map(),
+        cueOuts: new Map(),
+        discontinuities: new Map(),
+        durations: new Map(),
+        timestamps: new Map(),
+        totalDiscontinuities: 0
+    };
+}
+/**
+ * Records per-segment metadata from a parsed upstream segment into a SegmentMetadata instance. Stores duration, upstream program-date-time (when available),
+ * discontinuity flag, and SCTE-35 cue markers.
+ *
+ * @param meta - The metadata instance to update.
+ * @param filename - The local segment filename (e.g., "segment0.ts").
+ * @param seg - The parsed segment with upstream metadata.
+ */
+function storeSegmentMetadata(meta, filename, seg) {
+    meta.durations.set(filename, seg.duration);
+    if (seg.programDateTime) {
+        meta.timestamps.set(filename, seg.programDateTime);
+    }
+    if (seg.discontinuity) {
+        meta.discontinuities.set(filename, true);
+        meta.totalDiscontinuities++;
+    }
+    if (seg.cueIn) {
+        meta.cueIns.set(filename, true);
+    }
+    if (seg.cueOut !== null) {
+        meta.cueOuts.set(filename, seg.cueOut);
+    }
+    if (seg.cueOutCont !== null) {
+        meta.cueOutConts.set(filename, seg.cueOutCont);
+    }
+}
+/**
+ * Builds a PlaylistSegmentEntry from a segment's metadata. Translates the per-segment Maps (durations, timestamps, discontinuities, cue markers) into the shared entry
+ * type used by the playlist builder. Used by both buildVariantPlaylist() and buildCompositePlaylist() to avoid duplicating the field-by-field metadata lookup.
+ *
+ * @param filename - The segment filename (e.g., "segmentN.ts" where N starts at prerollSegmentCount).
+ * @param metadata - The metadata instance to read from.
+ * @param defaultDuration - Fallback duration when the metadata Map has no entry for this filename.
+ * @returns A PlaylistSegmentEntry with all applicable metadata fields set.
+ */
+function buildEntryFromMetadata(filename, metadata, defaultDuration) {
+    const entry = {
+        duration: metadata.durations.get(filename) ?? defaultDuration,
+        url: filename
+    };
+    if (metadata.discontinuities.has(filename)) {
+        entry.discontinuity = true;
+    }
+    const timestamp = metadata.timestamps.get(filename);
+    if (timestamp) {
+        entry.programDateTime = timestamp;
+    }
+    if (metadata.cueIns.has(filename)) {
+        entry.cueIn = true;
+    }
+    const cueOut = metadata.cueOuts.get(filename);
+    if (cueOut !== undefined) {
+        entry.cueOut = cueOut;
+    }
+    const cueOutCont = metadata.cueOutConts.get(filename);
+    if (cueOutCont !== undefined) {
+        entry.cueOutCont = cueOutCont;
+    }
+    return entry;
+}
+/**
+ * Prunes stale entries from a SegmentMetadata instance. Removes entries for segments that are no longer in the active segment set (evicted from the sliding window).
+ * This prevents unbounded growth over hours of streaming.
+ *
+ * @param meta - The metadata instance to prune.
+ * @param activeSegments - Set of filenames currently in the segment store.
+ */
+function pruneMetadata(meta, activeSegments) {
+    for (const key of meta.durations.keys()) {
+        if (!activeSegments.has(key)) {
+            meta.cueIns.delete(key);
+            meta.cueOutConts.delete(key);
+            meta.cueOuts.delete(key);
+            meta.discontinuities.delete(key);
+            meta.durations.delete(key);
+            meta.timestamps.delete(key);
+        }
+    }
+}
+// Audio Stream Handler.
+/**
+ * Polls the audio variant manifest and fetches new audio segments. Combines the audio manifest poll and segment processing into a single entry point that mirrors the
+ * video path. Only called for streams with separate audio renditions.
+ *
+ * @param ctx - Shared proxy context with lifecycle state, stats, channel name, and error callback.
+ * @param audio - Audio-specific tracking state (sequence tracking, metadata, failure counters).
+ * @param fetchSegment - Closure-bound segment fetch function that handles HTTP fetch, decryption, and error tracking.
+ * @returns True if new audio segments were stored, false otherwise.
+ */
+async function pollAudioStream(ctx, audio, fetchSegment) {
+    if (ctx.lifecycle.stopped || !audio.variantUrl) {
+        return false;
+    }
+    try {
+        const response = await chromeFetch(audio.variantUrl, { signal: AbortSignal.timeout(SEGMENT_FETCH_TIMEOUT) });
+        if (!response.ok) {
+            audio.consecutiveManifestFailures++;
+            ctx.stats.totalFetchErrors++;
+            LOG.debug("native:proxy", "Audio manifest poll failed for %s: HTTP %s.", ctx.channelName, response.status);
+            if (audio.consecutiveManifestFailures >= MAX_MANIFEST_FAILURES) {
+                ctx.lifecycle.errorThresholdReached = true;
+                ctx.lifecycle.stopped = true;
+                ctx.onError("audio manifest poll failed " + String(audio.consecutiveManifestFailures) + " times");
+            }
+            return false;
+        }
+        audio.consecutiveManifestFailures = 0;
+        const body = await response.text();
+        return await processAudioStream(ctx, audio, body, audio.variantUrl, fetchSegment);
+    }
+    catch (error) {
+        audio.consecutiveManifestFailures++;
+        ctx.stats.totalFetchErrors++;
+        LOG.debug("native:proxy", "Audio manifest poll failed for %s: %s.", ctx.channelName, String(error));
+        if (audio.consecutiveManifestFailures >= MAX_MANIFEST_FAILURES) {
+            ctx.lifecycle.errorThresholdReached = true;
+            ctx.lifecycle.stopped = true;
+            ctx.onError("audio manifest poll error: " + String(error));
+        }
+        return false;
+    }
+}
+/**
+ * Parses an audio variant manifest and fetches new audio segments. Handles sequence tracking, high-water mark filtering, token refresh detection, and metadata storage.
+ * Playlist generation is handled by the caller after both video and audio segments are stored.
+ *
+ * @param ctx - Shared proxy context.
+ * @param audio - Audio-specific tracking state.
+ * @param body - The audio variant manifest text content.
+ * @param baseUrl - The audio variant URL for resolving relative segment URLs.
+ * @param fetchSegment - Closure-bound segment fetch function.
+ * @returns True if new segments were stored, false if the media sequence hadn't advanced.
+ */
+async function processAudioStream(ctx, audio, body, baseUrl, fetchSegment) {
+    const { mediaSequence, segments, targetDuration } = parseVariantManifest(body, baseUrl);
+    audio.lastTargetDuration = targetDuration;
+    // Prune old entries from audio fetchedSequences and audio metadata on each poll cycle.
+    for (const seq of audio.fetchedSequences) {
+        if (seq < mediaSequence) {
+            audio.fetchedSequences.delete(seq);
+        }
+    }
+    const audioPruneStream = getStream(ctx.streamId);
+    const activeAudioSegments = audioPruneStream ? new Set(audioPruneStream.hls.audioSegments.keys()) : new Set();
+    pruneMetadata(audio.metadata, activeAudioSegments);
+    // Filter audio segments using the same high-water mark and token refresh detection as the video path.
+    let newSegments;
+    if (audio.highWaterSequence === -1) {
+        newSegments = segments.slice(-CONFIG.hls.maxSegments);
+    }
+    else {
+        newSegments = segments.filter((s) => (s.sequence > audio.highWaterSequence) && !audio.fetchedSequences.has(s.sequence));
+        if ((newSegments.length === 0) && audio.tokenRefreshPending && (segments.length > 0)) {
+            LOG.debug("native:proxy", "Audio sequence timeline reset detected for %s after token refresh. Resetting high-water mark from %s.", ctx.channelName, audio.highWaterSequence);
+            audio.highWaterSequence = -1;
+            audio.tokenRefreshPending = false;
+            newSegments = segments.slice(-CONFIG.hls.maxSegments);
+        }
+    }
+    if ((newSegments.length > 0) && audio.tokenRefreshPending) {
+        audio.tokenRefreshPending = false;
+    }
+    if (newSegments.length === 0) {
+        return false;
+    }
+    LOG.debug("native:proxy", "Fetching %s new audio segment(s) for %s (sequence %s).", newSegments.length, ctx.channelName, mediaSequence);
+    let storedAny = false;
+    for (const seg of newSegments) {
+        if (ctx.lifecycle.stopped) {
+            break;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const segmentData = await fetchSegment(audio.segmentTracker, seg.url, seg.sequence, seg.ivHex, seg.keyUrl);
+        if (!segmentData) {
+            continue;
+        }
+        const filename = "audio" + String(audio.segmentIndex) + ".ts";
+        storeAudioSegment(ctx.streamId, filename, segmentData);
+        audio.fetchedSequences.add(seg.sequence);
+        audio.highWaterSequence = Math.max(audio.highWaterSequence, seg.sequence);
+        storeSegmentMetadata(audio.metadata, filename, seg);
+        storedAny = true;
+        audio.segmentIndex++;
+        ctx.stats.totalSegmentsFetched++;
+        LOG.debug("native:proxy", "Stored %s (%s bytes, seq %s) for %s.", filename, segmentData.length, seg.sequence, ctx.channelName);
+    }
+    return storedAny;
+}
+// Composite Playlist Builder.
+/**
+ * Builds a composite playlist with fMP4 preroll entries and MPEG-TS real entries. Uses the same compositor and builder as the capture path's generatePlaylist(),
+ * ensuring identical windowing behavior (maxPrerollInWindow cap, progressive falloff). The DISCONTINUITY tag at the preroll-to-real boundary signals the container
+ * format change (fMP4 → MPEG-TS), which is spec-compliant per RFC 8216 Section 4.3.3.3. VERSION:7 is used to support EXT-X-MAP for the preroll init segment;
+ * after preroll entries fall off the window, VERSION:7 remains but is backward-compatible with the MPEG-TS entries.
+ *
+ * @param options - Composite playlist configuration with segment data, preroll settings, and composite tracking state.
+ * @returns The formatted composite m3u8 playlist string.
+ */
+function buildCompositePlaylist(options) {
+    const { composite, prerollBaseUrl, prerollCodec, prerollSegmentCount, segmentEntries, segmentIndex, targetDuration, videoMetadata } = options;
+    // Compute the sliding window start index via the compositor. The three-way max prevents negative indices, enforces the sliding window rule, and caps preroll
+    // entries at maxPrerollInWindow to force clients past preroll toward the live edge.
+    const realSegmentCount = segmentEntries.length;
+    const startIndex = computePrerollWindow({
+        currentSegmentIndex: segmentIndex,
+        maxSegments: CONFIG.hls.maxSegments,
+        prerollSegmentCount,
+        realSegmentCount
+    });
+    // Build fMP4 preroll entries for preroll indices still in the window. These reference the global /preroll/ routes with absolute URLs and .m4s extension.
+    let prerollEntries = [];
+    if (startIndex < prerollSegmentCount) {
+        prerollEntries = buildPrerollEntries({ baseUrl: prerollBaseUrl, codec: prerollCodec, extension: ".m4s", prerollSegmentCount, startIndex });
+    }
+    // Build real MPEG-TS entries from the video metadata maps via the shared helper.
+    const realEntries = segmentEntries.map((filename) => buildEntryFromMetadata(filename, videoMetadata, targetDuration));
+    // Mark the preroll-to-real boundary on the first real entry when preroll entries are present in the window. This is a playlist-level concern (the stitching of
+    // preroll before real content), not a segment-level property — so it's applied here in the composite builder rather than injected into videoMetadata at segment
+    // storage time. This keeps the metadata clean (upstream discontinuities only) and avoids a stray DISCONTINUITY tag on fast streams where the composite never
+    // activates.
+    if ((prerollEntries.length > 0) && (realEntries.length > 0)) {
+        realEntries[0].discontinuity = true;
+    }
+    // Bootstrap the composite discontinuity tracker on the first call. This captures any upstream discontinuities that occurred before the composite path activated
+    // (e.g., the proxy ran in non-composite mode while the preroll timer hadn't fired). The Map has filenames of currently-stored discontinuity segments; the counter
+    // includes historical ones that pruned out of the Map. The difference becomes a fixed offset for segments we can never recover by filename.
+    if (!composite.seeded) {
+        for (const filename of videoMetadata.discontinuities.keys()) {
+            composite.discontinuities.add(filename);
+        }
+        composite.baseOffset = videoMetadata.totalDiscontinuities - videoMetadata.discontinuities.size;
+        composite.seeded = true;
+    }
+    // Compute DISCONTINUITY-SEQUENCE using the composite path's independent discontinuity tracker. For each entry with discontinuity=true (whether from upstream
+    // metadata or the synthetic preroll boundary), record its URL in the Set. The Set grows monotonically — once a discontinuity is observed, it's tracked forever.
+    // DISCONTINUITY-SEQUENCE = total ever observed (offset + Set size) minus those visible in the current window.
+    const entries = [...prerollEntries, ...realEntries];
+    let windowDiscontinuities = 0;
+    for (const entry of entries) {
+        if (entry.discontinuity) {
+            composite.discontinuities.add(entry.url);
+            windowDiscontinuities++;
+        }
+    }
+    const discSeq = (composite.baseOffset + composite.discontinuities.size) - windowDiscontinuities;
+    const discontinuitySequence = (discSeq > 0) ? discSeq : undefined;
+    // Determine the initial MAP URI. When the window starts with preroll entries, the preroll init segment (fMP4) is referenced. When the window has moved past all
+    // preroll, no MAP is needed (MPEG-TS segments are self-describing). The DISCONTINUITY tag at the preroll-to-real boundary invalidates the MAP per RFC 8216
+    // Section 4.3.3.3, so MPEG-TS entries after the boundary carry their codec config inline.
+    const initialMapUri = (prerollEntries.length > 0) ? (prerollBaseUrl + "/preroll/" + prerollCodec + "/init.mp4") : undefined;
+    return buildPlaylist({
+        discontinuitySequence,
+        initialMapUri,
+        mediaSequence: startIndex,
+        targetDuration,
+        version: 7
+    }, entries);
+}
+/**
+ * Creates a native HLS proxy that polls a variant manifest, fetches segments, and generates playlists.
+ *
+ * @param options - Proxy configuration.
+ * @returns The native proxy interface.
+ */
+export function createNativeProxy(options) {
+    const { channelName, encryption, keyUrl, onError, streamId } = options;
+    const hasAudio = options.audioVariantUrl !== null;
+    let activeCdpSession = options.cdpSession;
+    // Preroll segment index offset. When preroll is ready (prerollSegmentCount > 0), real segments start numbering after the preroll range (e.g., segmentN.ts where
+    // N = prerollSegmentCount). This offset is unconditional — it reserves the index space for preroll regardless of whether the deferred preroll timer fires.
+    // The composite playlist behavior (including preroll entries) is determined dynamically by checking stream.hls.prerollStartTime at playlist generation time.
+    const prerollCodec = options.prerollCodec ?? "h264";
+    const prerollSegmentCount = options.prerollSegmentCount ?? 0;
+    /* Proxy state. These track segment storage, manifest polling, error thresholds, and playlist generation across the proxy's lifetime. Mutable variables are organized
+     * into typed state objects by subsystem (lifecycle, video tracking, audio tracking, composite playlist, statistics) to clarify ownership and interaction boundaries.
+     * The ProxyContext bundles immutable references with shared mutable state for extracted module-level functions.
+     */
+    // Proxy lifecycle state. Controls whether the proxy is running, tracks readiness signaling, and manages poll timing.
+    const lifecycle = {
+        errorThresholdReached: false,
+        firstPollComplete: false,
+        manifestBackoffMs: MANIFEST_BACKOFF_BASE,
+        pollTimer: null,
+        readinessSignaled: false,
+        stopped: false,
+        tokenRefreshTimer: null
+    };
+    // Video segment and manifest tracking state.
+    const video = {
+        consecutiveManifestFailures: 0,
+        fetchedSequences: new Set(),
+        highWaterSequence: -1,
+        lastMediaSequence: -1,
+        lastSegmentSize: null,
+        lastSegmentTime: 0,
+        lastTargetDuration: 6,
+        metadata: createSegmentMetadata(),
+        segmentIndex: prerollSegmentCount,
+        segmentTracker: { consecutiveFailures: 0, debugLabel: "Segment", label: "segment" },
+        tokenRefreshPending: false,
+        variantUrl: options.variantUrl
+    };
+    // Audio segment and manifest tracking state for streams with separate audio renditions.
+    const audio = {
+        consecutiveManifestFailures: 0,
+        fetchedSequences: new Set(),
+        highWaterSequence: -1,
+        lastTargetDuration: 6,
+        metadata: createSegmentMetadata(),
+        segmentIndex: 0,
+        segmentTracker: { consecutiveFailures: 0, debugLabel: "Audio segment", label: "audio segment" },
+        tokenRefreshPending: false,
+        variantUrl: options.audioVariantUrl
+    };
+    // Composite playlist discontinuity tracking. This is the composite path's independent source of truth for DISCONTINUITY-SEQUENCE computation. The Set records URLs
+    // of entries that have had discontinuity=true in any composite playlist (upstream or the synthetic preroll boundary). It grows monotonically — once a discontinuity
+    // is observed, it's tracked forever. On the first composite call, the Set is bootstrapped from video.metadata to capture any upstream discontinuities that occurred
+    // before the composite path activated. The offset accounts for historical discontinuities that pruned out of the metadata's Map but are preserved in its counter.
+    // After bootstrap, the Set is self-sufficient. DISCONTINUITY-SEQUENCE = (offset + set.size) - windowDiscontinuities.
+    const composite = {
+        baseOffset: 0,
+        discontinuities: new Set(),
+        seeded: false
+    };
+    // Cumulative statistics.
+    const stats = {
+        totalFetchErrors: 0,
+        totalSegmentsFetched: 0,
+        totalTokenRefreshes: 0
+    };
+    // Shared context for extracted module-level functions. Bundles immutable references with shared mutable state objects.
+    const ctx = { channelName, lifecycle, onError, stats, streamId };
+    // AES-128 decryption key cache. Maps key URLs to their fetched 16-byte keys. Each segment in a manifest can reference a different key URL (key rotation), so we
+    // cache by URL rather than maintaining a single "current key". The coordinator pre-fetches the initial key, which is seeded into the cache here.
+    const keysByUrl = new Map();
+    if (options.prefetchedKey && keyUrl) {
+        keysByUrl.set(keyUrl, options.prefetchedKey);
+    }
+    /**
+     * Computes the next retry delay with exponential backoff and jitter. Doubles the current backoff (capped at MANIFEST_BACKOFF_CAP) and applies +/-20% jitter.
+     * @returns The jittered delay in milliseconds.
+     */
+    function nextBackoffDelay() {
+        lifecycle.manifestBackoffMs = Math.min(lifecycle.manifestBackoffMs * 2, MANIFEST_BACKOFF_CAP);
+        const jitter = 0.8 + (Math.random() * 0.4);
+        return Math.round(lifecycle.manifestBackoffMs * jitter);
+    }
+    /**
+     * Orchestrates the poll cycle: fetches video and audio manifests in parallel, stores segments, and generates playlists after both stores are updated.
+     */
+    async function pollManifest() {
+        if (lifecycle.stopped) {
+            return;
+        }
+        const pollElapsed = startTimer();
+        try {
+            const response = await chromeFetch(video.variantUrl, { signal: AbortSignal.timeout(SEGMENT_FETCH_TIMEOUT) });
+            if (!response.ok) {
+                video.consecutiveManifestFailures++;
+                stats.totalFetchErrors++;
+                // Classify the error. Client errors (4xx) typically indicate permanent issues (auth expiry, content removed) that won't self-resolve. Server errors (5xx)
+                // are transient CDN issues that usually recover within a few seconds. Client errors use the base threshold; server errors get double the attempts.
+                const isClientError = (response.status >= 400) && (response.status < 500);
+                const effectiveThreshold = isClientError ? MAX_MANIFEST_FAILURES : (MAX_MANIFEST_FAILURES * 2);
+                LOG.debug("native:proxy", "Manifest poll failed for %s: HTTP %s (%s, %s/%s).", channelName, response.status, isClientError ? "client" : "server", video.consecutiveManifestFailures, effectiveThreshold);
+                if (video.consecutiveManifestFailures >= effectiveThreshold) {
+                    lifecycle.errorThresholdReached = true;
+                    lifecycle.stopped = true;
+                    onError("manifest poll failed " + String(video.consecutiveManifestFailures) + " times (HTTP " + String(response.status) + ")");
+                    return;
+                }
+                schedulePoll(nextBackoffDelay());
+                return;
+            }
+            video.consecutiveManifestFailures = 0;
+            lifecycle.manifestBackoffMs = MANIFEST_BACKOFF_BASE;
+            const body = await response.text();
+            LOG.debug("native:proxy", "Manifest poll for %s completed in %sms.", channelName, pollElapsed());
+            LOG.debug("native:manifest", "Variant manifest for %s:\n%s", channelName, body);
+            // Fetch and store video and audio segments in parallel so neither delays the other, and generate playlists after both stores are updated. This ensures video
+            // and audio playlists are published atomically — no window where a client sees a master playlist referencing audio.m3u8 before audio segments exist.
+            let hasNewVideoSegments;
+            let hasNewAudioSegments = false;
+            if (hasAudio) {
+                [hasNewVideoSegments, hasNewAudioSegments] = await Promise.all([processManifest(body), pollAudioStream(ctx, audio, fetchTrackedSegment)]);
+            }
+            else {
+                hasNewVideoSegments = await processManifest(body);
+            }
+            if (hasNewVideoSegments || hasNewAudioSegments) {
+                generatePlaylist(video.lastTargetDuration);
+                if (hasAudio) {
+                    generateAudioPlaylist(audio.lastTargetDuration);
+                }
+            }
+            // Set firstPollComplete when segments are available. For streams with separate audio, require both video and audio segments before signaling readiness to
+            // prevent publishing a master playlist before both variant playlists have content.
+            if (!lifecycle.firstPollComplete && (video.segmentIndex > 0) && (!hasAudio || (audio.segmentIndex > 0))) {
+                lifecycle.firstPollComplete = true;
+            }
+            // Signal playlist readiness after the first poll completes. Note: initSegmentReady is signaled immediately when the proxy starts (in hls.ts) since native
+            // MPEG-TS has no separate init segment.
+            if (lifecycle.firstPollComplete && !lifecycle.readinessSignaled) {
+                lifecycle.readinessSignaled = true;
+                const stream = getStream(streamId);
+                if (stream) {
+                    stream.hls.signalPlaylistReady();
+                }
+                LOG.debug("native:proxy", "First poll cycle complete for %s. Segment index: %s.", channelName, video.segmentIndex);
+            }
+        }
+        catch (error) {
+            // Network errors (timeouts, DNS failures, connection resets) are transient — use the extended threshold and backoff.
+            video.consecutiveManifestFailures++;
+            stats.totalFetchErrors++;
+            LOG.debug("native:proxy", "Manifest poll failed for %s: %s (%s/%s).", channelName, String(error), video.consecutiveManifestFailures, MAX_MANIFEST_FAILURES * 2);
+            if (video.consecutiveManifestFailures >= (MAX_MANIFEST_FAILURES * 2)) {
+                lifecycle.errorThresholdReached = true;
+                lifecycle.stopped = true;
+                onError("manifest poll error: " + String(error));
+                return;
+            }
+            schedulePoll(nextBackoffDelay());
+            return;
+        }
+        // Schedule the next poll at roughly half the target segment duration for timely detection of new segments.
+        lifecycle.manifestBackoffMs = MANIFEST_BACKOFF_BASE;
+        schedulePoll(MANIFEST_BACKOFF_BASE);
+    }
+    /**
+     * Parses a variant manifest and fetches new segments. Playlist generation is handled by the caller after both video and audio segments are stored.
+     *
+     * @param body - The variant manifest text content.
+     * @returns True if new segments were stored, false if the media sequence hadn't advanced.
+     */
+    async function processManifest(body) {
+        const { mediaSequence, segments, targetDuration } = parseVariantManifest(body, video.variantUrl);
+        video.lastTargetDuration = targetDuration;
+        // Prune old entries from the fetchedSequences Set and segment metadata on each poll cycle. The provider's media sequence window slides forward, so entries below
+        // the current base sequence will never be checked again. Without pruning, these structures grow unboundedly over hours of streaming.
+        for (const seq of video.fetchedSequences) {
+            if (seq < mediaSequence) {
+                video.fetchedSequences.delete(seq);
+            }
+        }
+        const pruneStream = getStream(streamId);
+        const activeVideoSegments = pruneStream ? new Set(pruneStream.hls.segments.keys()) : new Set();
+        pruneMetadata(video.metadata, activeVideoSegments);
+        // Filter segments to only those that advance the live edge. On the first poll (highWaterSequence === -1), we have no baseline yet, so we take the last
+        // maxSegments entries to fill the initial playlist window. On subsequent polls, we only fetch segments with sequence numbers above the high-water mark. This
+        // filters out DAI backfill segments from interleaved session windows — segments that are "new" (not in fetchedSequences) but have lower sequence numbers than
+        // what we've already served, causing PTS discontinuities and visible playback glitches.
+        let newSegments;
+        if (video.highWaterSequence === -1) {
+            // First poll — no baseline. Take the tail of the manifest to fill the playlist window.
+            newSegments = segments.slice(-CONFIG.hls.maxSegments);
+        }
+        else {
+            // Subsequent polls — only fetch segments that advance past the high-water mark.
+            newSegments = segments.filter((s) => (s.sequence > video.highWaterSequence) && !video.fetchedSequences.has(s.sequence));
+            // Detect CDN sequence timeline reset after a token refresh. Some CDNs (e.g., Fox Sports) create a new session with sequence numbers starting at 0 when
+            // tokens are refreshed. If the first poll after a refresh produces zero segments above the high-water mark, the timeline has genuinely reset — clear the
+            // high-water mark and re-process the same manifest with the tail-fill strategy.
+            if ((newSegments.length === 0) && video.tokenRefreshPending && (segments.length > 0)) {
+                LOG.debug("native:proxy", "Sequence timeline reset detected for %s after token refresh. Resetting high-water mark from %s.", channelName, video.highWaterSequence);
+                video.highWaterSequence = -1;
+                video.tokenRefreshPending = false;
+                newSegments = segments.slice(-CONFIG.hls.maxSegments);
+            }
+        }
+        // Clear the token refresh flag on the first poll that produces segments, whether via normal filtering or after a reset detection.
+        if ((newSegments.length > 0) && video.tokenRefreshPending) {
+            video.tokenRefreshPending = false;
+        }
+        if (newSegments.length === 0) {
+            // No new segments — the media sequence hasn't advanced.
+            if (video.lastMediaSequence === mediaSequence) {
+                LOG.debug("native:proxy", "No new segments for %s (sequence still %s).", channelName, mediaSequence);
+            }
+            video.lastMediaSequence = mediaSequence;
+            return false;
+        }
+        LOG.debug("native:proxy", "Fetching %s new segment(s) for %s (sequence %s).", newSegments.length, channelName, mediaSequence);
+        video.lastMediaSequence = mediaSequence;
+        // Fetch and store each new segment sequentially. Track whether at least one segment was stored so the caller only generates playlists when data actually changed.
+        let storedAny = false;
+        for (const seg of newSegments) {
+            if (lifecycle.stopped) {
+                break;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const segmentData = await fetchTrackedSegment(video.segmentTracker, seg.url, seg.sequence, seg.ivHex, seg.keyUrl);
+            if (!segmentData) {
+                continue;
+            }
+            const filename = "segment" + String(video.segmentIndex) + ".ts";
+            // Check segment count before store to detect rotation (oldest segment evicted to enforce maxSegments limit).
+            const stream = getStream(streamId);
+            const countBefore = stream?.hls.segments.size ?? 0;
+            storeSegment(streamId, filename, segmentData);
+            video.fetchedSequences.add(seg.sequence);
+            video.highWaterSequence = Math.max(video.highWaterSequence, seg.sequence);
+            storeSegmentMetadata(video.metadata, filename, seg);
+            storedAny = true;
+            video.lastSegmentSize = segmentData.length;
+            video.lastSegmentTime = Date.now();
+            video.segmentIndex++;
+            stats.totalSegmentsFetched++;
+            // Log the first segment fetch latency for timing diagnostics.
+            if (stats.totalSegmentsFetched === 1) {
+                LOG.debug("timing:native", "First segment fetched for %s (%s bytes).", channelName, segmentData.length);
+            }
+            // Detect segment rotation — if the count didn't increase, the oldest segment was evicted.
+            const countAfter = stream?.hls.segments.size ?? 0;
+            if ((countAfter <= countBefore) && (countBefore > 0)) {
+                LOG.debug("native:proxy", "Segment rotated for %s (oldest removed, %s segments retained).", channelName, countAfter);
+            }
+            LOG.debug("native:proxy", "Stored %s (%s bytes, seq %s) for %s.", filename, segmentData.length, seg.sequence, channelName);
+        }
+        return storedAny;
+    }
+    /**
+     * Fetches and optionally decrypts a segment. This is the shared core used by both video and audio fetch paths. It handles the HTTP fetch, AES-128 decryption with
+     * key caching, and IV derivation. Error tracking is the caller's responsibility since video and audio have independent failure thresholds.
+     *
+     * @param url - The segment URL.
+     * @param sequence - The media sequence number (for IV derivation).
+     * @param ivHex - Explicit IV hex string from the manifest, or null.
+     * @param segKeyUrl - The key URL for this specific segment from the manifest's #EXT-X-KEY tag, or null for clear segments.
+     * @returns The segment data (decrypted if necessary), or null on failure.
+     */
+    async function fetchAndDecryptSegment(url, sequence, ivHex, segKeyUrl) {
+        const response = await chromeFetch(url, { signal: AbortSignal.timeout(SEGMENT_FETCH_TIMEOUT) });
+        if (!response.ok) {
+            LOG.debug("native:proxy", "Segment fetch failed for %s: HTTP %s.", channelName, response.status);
+            return null;
+        }
+        let data = Buffer.from(await response.arrayBuffer());
+        // Decrypt if this segment has a key URL. The manifest's #EXT-X-KEY tag is authoritative — DAI streams can switch between clear and AES-128 mid-stream (e.g., ad
+        // pods encrypted while main content is clear), so the initial probe classification cannot be relied upon. Segments before the first #EXT-X-KEY tag have
+        // segKeyUrl === null (clear).
+        if (segKeyUrl) {
+            // Look up the key in the per-URL cache, or fetch it if not cached.
+            let key = keysByUrl.get(segKeyUrl);
+            if (!key) {
+                key = await fetchDecryptionKey(segKeyUrl) ?? undefined;
+                if (!key) {
+                    LOG.debug("native:proxy", "Decryption key unavailable for %s (key URL: %s).", channelName, segKeyUrl.slice(0, 80));
+                    return null;
+                }
+                keysByUrl.set(segKeyUrl, key);
+                LOG.debug("native:proxy", "New decryption key cached for %s.", channelName);
+            }
+            // Determine the IV: use explicit IV from the manifest, or derive from the media sequence number.
+            const iv = ivHex ? (parseExplicitIv(ivHex) ?? deriveIvFromSequence(sequence)) : deriveIvFromSequence(sequence);
+            LOG.debug("native:decrypt", "IV source for sequence %s: %s.", sequence, ivHex ? "explicit" : "sequence");
+            data = decryptSegment(data, key, iv);
+        }
+        return data;
+    }
+    /**
+     * Fetches a segment with error tracking. Wraps fetchAndDecryptSegment with per-tracker failure counting. Consecutive failures trigger the error threshold which
+     * stops the proxy and signals the monitor for recovery. Used for both video and audio segments with independent trackers.
+     *
+     * @param tracker - Mutable error tracking state with labels for log and error messages.
+     * @param url - The segment URL.
+     * @param sequence - The media sequence number (for IV derivation).
+     * @param ivHex - Explicit IV hex string from the manifest, or null.
+     * @param segKeyUrl - The key URL for this specific segment, or null for clear segments.
+     * @returns The segment data (decrypted if necessary), or null on failure.
+     */
+    async function fetchTrackedSegment(tracker, url, sequence, ivHex, segKeyUrl) {
+        try {
+            const data = await fetchAndDecryptSegment(url, sequence, ivHex, segKeyUrl);
+            if (!data) {
+                tracker.consecutiveFailures++;
+                stats.totalFetchErrors++;
+                if (tracker.consecutiveFailures >= MAX_SEGMENT_FAILURES) {
+                    lifecycle.errorThresholdReached = true;
+                    lifecycle.stopped = true;
+                    onError(tracker.label + " fetch failed " + String(tracker.consecutiveFailures) + " times");
+                }
+                return null;
+            }
+            tracker.consecutiveFailures = 0;
+            return data;
+        }
+        catch (error) {
+            tracker.consecutiveFailures++;
+            stats.totalFetchErrors++;
+            LOG.debug("native:proxy", "%s fetch failed for %s: %s.", tracker.debugLabel, channelName, String(error));
+            if (tracker.consecutiveFailures >= MAX_SEGMENT_FAILURES) {
+                lifecycle.errorThresholdReached = true;
+                lifecycle.stopped = true;
+                onError(tracker.label + " fetch error: " + String(error));
+            }
+            return null;
+        }
+    }
+    /**
+     * Generates playlists from the stored segments. For streams without separate audio, generates a single variant playlist. When preroll is active (muxed audio only),
+     * produces a composite playlist with fMP4 preroll entries and MPEG-TS real entries bridged by a DISCONTINUITY tag. The preroll entries use the same fMP4 segments
+     * served during the standalone preroll phase, ensuring smooth MEDIA-SEQUENCE progression. For streams with separate audio, generates a master playlist referencing
+     * video.m3u8 and audio.m3u8, plus individual variant playlists for each (no preroll — preroll is muxed and can't be split into separate renditions).
+     *
+     * @param targetDuration - The #EXT-X-TARGETDURATION value from the provider's manifest.
+     */
+    function generatePlaylist(targetDuration) {
+        const stream = getStream(streamId);
+        if (!stream) {
+            return;
+        }
+        const segmentEntries = Array.from(stream.hls.segments.keys());
+        if (!hasAudio) {
+            if ((prerollSegmentCount > 0) && stream.hls.prerollStartTime && stream.hls.prerollBaseUrl) {
+                // Composite playlist with fMP4 preroll entries + MPEG-TS real entries. The prerollStartTime check ensures we only include preroll entries when the deferred
+                // timer has fired and the client is actually watching preroll. Without this check, fast native streams (where real content arrives before the preroll delay)
+                // would include unnecessary preroll entries. The compositor handles the sliding window with the maxPrerollInWindow cap.
+                updatePlaylist(streamId, buildCompositePlaylist({
+                    composite,
+                    prerollBaseUrl: stream.hls.prerollBaseUrl,
+                    prerollCodec,
+                    prerollSegmentCount,
+                    segmentEntries,
+                    segmentIndex: video.segmentIndex,
+                    targetDuration,
+                    videoMetadata: video.metadata
+                }));
+            }
+            else {
+                // No preroll active — standard variant playlist. The segment index may still be offset (starting at prerollSegmentCount) to reserve the index space, but no
+                // preroll entries are included.
+                updatePlaylist(streamId, buildVariantPlaylist(segmentEntries, video.metadata, "segment", targetDuration));
+            }
+        }
+        else {
+            // Separate audio — generate video variant playlist and master playlist. Preroll is not supported for separate audio streams (preroll is muxed).
+            updateVideoPlaylist(streamId, buildVariantPlaylist(segmentEntries, video.metadata, "segment", targetDuration));
+            // Estimate bandwidth from stored segment sizes and durations. Sum total bytes and total duration across video segments, then convert to bits per second.
+            // Falls back to 5 Mbps when no duration data is available (first segment before durations are populated).
+            let bandwidth = 5000000;
+            let totalBytes = 0;
+            let totalDuration = 0;
+            for (const filename of segmentEntries) {
+                const size = stream.hls.segments.get(filename)?.length ?? 0;
+                const duration = video.metadata.durations.get(filename);
+                if (duration) {
+                    totalBytes += size;
+                    totalDuration += duration;
+                }
+            }
+            if (totalDuration > 0) {
+                bandwidth = Math.round((totalBytes * 8) / totalDuration);
+            }
+            // Generate the master playlist referencing video.m3u8 and audio.m3u8.
+            const masterPlaylist = "#EXTM3U\n" +
+                "#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"audio\",NAME=\"English\",DEFAULT=YES,AUTOSELECT=YES,URI=\"audio.m3u8\"\n" +
+                "#EXT-X-STREAM-INF:BANDWIDTH=" + String(bandwidth) + ",AUDIO=\"audio\"\n" +
+                "video.m3u8\n";
+            updatePlaylist(streamId, masterPlaylist);
+        }
+        LOG.debug("native:proxy", "Playlist generated for %s with %s segment(s), target duration %ss.", channelName, segmentEntries.length, targetDuration);
+    }
+    /**
+     * Generates the audio variant playlist from stored audio segments.
+     *
+     * @param targetDuration - The #EXT-X-TARGETDURATION value from the audio manifest.
+     */
+    function generateAudioPlaylist(targetDuration) {
+        const stream = getStream(streamId);
+        if (!stream) {
+            return;
+        }
+        const audioEntries = Array.from(stream.hls.audioSegments.keys());
+        updateAudioPlaylist(streamId, buildVariantPlaylist(audioEntries, audio.metadata, "audio", targetDuration));
+    }
+    /**
+     * Schedules the next manifest poll after a delay.
+     *
+     * @param delayMs - Delay in milliseconds before the next poll.
+     */
+    function schedulePoll(delayMs) {
+        if (lifecycle.stopped) {
+            return;
+        }
+        lifecycle.pollTimer = setTimeout(() => {
+            void pollManifest();
+        }, delayMs);
+    }
+    return {
+        getConsecutiveErrors: () => video.segmentTracker.consecutiveFailures + video.consecutiveManifestFailures +
+            audio.segmentTracker.consecutiveFailures + audio.consecutiveManifestFailures,
+        getLastSegmentSize: () => video.lastSegmentSize,
+        getLastSegmentTime: () => video.lastSegmentTime,
+        getSegmentIndex: () => video.segmentIndex,
+        getStats: () => ({
+            fetchErrors: stats.totalFetchErrors,
+            segmentsFetched: stats.totalSegmentsFetched,
+            tokenRefreshes: stats.totalTokenRefreshes
+        }),
+        getTargetDuration: () => video.lastTargetDuration,
+        hasErrored: () => lifecycle.errorThresholdReached,
+        isStopped: () => lifecycle.stopped,
+        setTokenRefreshTimer: (timer) => {
+            lifecycle.tokenRefreshTimer = timer;
+        },
+        start: () => {
+            LOG.debug("native:proxy", "Starting native proxy for %s (%s).", channelName, encryption);
+            void pollManifest();
+        },
+        stop: () => {
+            lifecycle.stopped = true;
+            if (lifecycle.pollTimer) {
+                clearTimeout(lifecycle.pollTimer);
+                lifecycle.pollTimer = null;
+            }
+            // Cancel the pending token refresh timer to prevent fire-after-termination. Without this, the timer fires on a stopped proxy and attempts to navigate a
+            // potentially closed or reused page.
+            if (lifecycle.tokenRefreshTimer) {
+                clearTimeout(lifecycle.tokenRefreshTimer);
+                lifecycle.tokenRefreshTimer = null;
+            }
+            // Clean up the CDP session from manifest interception to prevent session leaks.
+            removeManifestInterceptor(activeCdpSession);
+            LOG.debug("native:proxy", "Stopped native proxy for %s.", channelName);
+        },
+        updateAudioVariantUrl: (newUrl) => {
+            audio.variantUrl = newUrl;
+            audio.fetchedSequences.clear();
+            audio.tokenRefreshPending = true;
+            LOG.debug("native:proxy", "Audio variant URL updated for %s.", channelName);
+        },
+        updateCdpSession: (session) => {
+            // Clean up the old CDP session before replacing it. This prevents session leaks when the session is swapped during token refresh or L2 recovery.
+            removeManifestInterceptor(activeCdpSession);
+            activeCdpSession = session;
+        },
+        updateVariantUrl: (newUrl) => {
+            video.variantUrl = newUrl;
+            stats.totalTokenRefreshes++;
+            // Clear the fetched set so sequence numbers from the old CDN session don't cause segments in the new session to be incorrectly filtered as "already fetched."
+            // The high-water mark is intentionally preserved — it's the same live stream with the same sequence timeline, just with fresh auth tokens. Resetting it would
+            // allow the proxy to re-fetch segments the client already consumed, causing PTS discontinuities and visible playback glitches. The tokenRefreshPending flag
+            // enables processManifest to detect genuine sequence timeline resets (e.g., Fox Sports) on the first poll after refresh.
+            video.fetchedSequences.clear();
+            video.lastMediaSequence = -1;
+            video.tokenRefreshPending = true;
+            LOG.debug("native:proxy", "Variant URL updated for %s. Segment tracking reset.", channelName);
+        }
+    };
+}
+//# sourceMappingURL=proxy.js.map