@bnhf/prismcast 1.3.4-2026.2.19

package/dist/streaming/mpegts.js

@@ -0,0 +1,248 @@
+import { LOG, formatError, spawnMpegTsRemuxer } from "../utils/index.js";
+import { awaitStreamReadySilent, initializeStream, sendValidationError, validateChannel } from "./hls.js";
+import { getStream, updateLastAccess } from "./registry.js";
+import { registerClient, unregisterClient } from "./clients.js";
+import { CONFIG } from "../config/index.js";
+import { StreamSetupError } from "./setup.js";
+import { getChannelStreamId } from "./lifecycle.js";
+import { waitForInitSegment } from "./hlsSegments.js";
+/* This module provides a continuous MPEG-TS byte stream from the same capture pipeline used for HLS. It is designed for HDHomeRun-compatible clients (such as Plex)
+ * that expect raw MPEG-TS when tuning a channel. The existing capture → segmenter → HLS segments flow is unchanged. Each MPEG-TS client gets its own FFmpeg remuxer
+ * that converts stored fMP4 segments to MPEG-TS with codec copy (no transcoding).
+ *
+ * Data flow per client:
+ * 1. Validate channel and check for existing stream
+ * 2. If new stream needed, flush HTTP 200 headers immediately (so the client sees "connection accepted")
+ * 3. initializeStream() starts the capture, or awaitStreamReadySilent() waits for an in-progress startup
+ * 4. Wait for the init segment (ftyp+moov codec configuration)
+ * 5. Spawn FFmpeg: -f mp4 -i pipe:0 -c copy -f mpegts pipe:1
+ * 6. Write init segment + existing media segments to FFmpeg stdin
+ * 7. Subscribe to segment events for new segments in real time
+ * 8. Pipe FFmpeg stdout to the HTTP response as video/mp2t
+ * 9. On client disconnect or stream termination, kill FFmpeg and clean up
+ *
+ * The header flush in step 2 prevents client timeouts. Without it, the client receives zero bytes until the entire stream setup completes (4-10+ seconds), which may
+ * exceed the client's connection timeout.
+ */
+// Public Endpoint Handler.
+/**
+ * Handles MPEG-TS stream requests. Validates the channel, flushes HTTP headers early for new streams, then ensures a capture is running, waits for the init segment,
+ * spawns a per-client FFmpeg remuxer, and streams the output.
+ *
+ * For new streams, headers are flushed before stream setup begins so the client sees an immediate 200 response. This prevents timeout failures during the 4-10+
+ * second startup sequence. The trade-off is that error responses cannot be sent after the flush — failures are logged server-side and the connection is closed.
+ *
+ * Route: GET /stream/:name
+ *
+ * @param req - Express request object.
+ * @param res - Express response object.
+ */
+export async function handleMpegTsStream(req, res) {
+    const channelName = req.params.name;
+    if (!channelName) {
+        res.status(400).send("Channel name is required.");
+        return;
+    }
+    // Check for an existing stream first. If one exists, we can skip validation and header flushing.
+    const existingStreamId = getChannelStreamId(channelName);
+    // Fast path: a real stream already exists. No early flush needed — the stream data will flow quickly.
+    if ((existingStreamId !== undefined) && (existingStreamId !== -1)) {
+        await serveMpegTsStream(existingStreamId, channelName, req, res);
+        return;
+    }
+    // If no existing stream or startup in progress, validate the channel before flushing headers. This ensures we can still return proper error responses for invalid
+    // channels, disabled channels, and login mode. Store the validated channel for use during stream initialization below.
+    let validatedChannel;
+    if (existingStreamId === undefined) {
+        const validation = validateChannel(channelName);
+        if (!validation.valid) {
+            sendValidationError(validation, res);
+            return;
+        }
+        validatedChannel = validation.channel;
+    }
+    // Flush HTTP 200 headers immediately. The client sees "connection accepted, data coming" and waits patiently. After this point, we cannot send error status codes —
+    // failures will close the connection with no data.
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "close");
+    res.setHeader("Content-Type", "video/mpeg");
+    res.setHeader("transferMode.dlna.org", "Streaming");
+    res.flushHeaders();
+    // Acquire the stream. If a startup is in progress (another request started it), poll silently. Otherwise, start a new stream via initializeStream().
+    let streamId;
+    if (existingStreamId === -1) {
+        // Another request is already starting this stream. Wait silently (no error responses possible after flush).
+        streamId = await awaitStreamReadySilent(channelName);
+        if (streamId === null) {
+            LOG.warn("MPEG-TS stream startup failed for %s (startup did not complete).", channelName);
+            res.end();
+            return;
+        }
+    }
+    else {
+        // Start a new stream directly. validatedChannel is guaranteed set: this branch runs only when existingStreamId === undefined, which requires successful
+        // validation above. Since headers are already flushed, errors are logged and the connection is closed.
+        if (!validatedChannel) {
+            res.end();
+            return;
+        }
+        try {
+            streamId = await initializeStream({
+                channel: validatedChannel,
+                channelName,
+                clientAddress: req.ip ?? req.socket.remoteAddress ?? null,
+                profileOverride: req.query.profile,
+                url: validatedChannel.url
+            });
+        }
+        catch (error) {
+            if (error instanceof StreamSetupError) {
+                LOG.warn("MPEG-TS stream startup failed for %s: %s.", channelName, error.userMessage);
+            }
+            else {
+                LOG.warn("MPEG-TS stream startup failed for %s: %s.", channelName, formatError(error));
+            }
+            res.end();
+            return;
+        }
+        if (streamId === null) {
+            LOG.warn("MPEG-TS stream startup failed for %s (terminated during setup).", channelName);
+            res.end();
+            return;
+        }
+    }
+    await serveMpegTsStream(streamId, channelName, req, res);
+}
+// Internal Helpers.
+/**
+ * Serves the MPEG-TS stream once a stream ID is available. Waits for the init segment, spawns the FFmpeg remuxer, and pipes the output to the response. This is the
+ * shared implementation used by both the fast path (existing stream) and the flush path (new stream).
+ *
+ * @param streamId - The numeric stream ID.
+ * @param channelName - The channel name for logging.
+ * @param req - Express request object.
+ * @param res - Express response object.
+ */
+async function serveMpegTsStream(streamId, channelName, req, res) {
+    // Wait for the init segment to be available. The init segment contains codec configuration (ftyp+moov boxes) that FFmpeg needs before it can process media segments.
+    const initReady = await waitForInitSegment(streamId, CONFIG.streaming.navigationTimeout);
+    if (!initReady) {
+        if (!res.headersSent) {
+            res.setHeader("Retry-After", "5");
+            res.status(503).send("Stream is starting. Please retry.");
+        }
+        else {
+            LOG.warn("MPEG-TS init segment timeout for %s.", channelName);
+            res.end();
+        }
+        return;
+    }
+    // Get the stream from the registry and verify it's still alive with a valid init segment.
+    const stream = getStream(streamId);
+    if (!stream?.hls.initSegment) {
+        if (!res.headersSent) {
+            res.status(500).send("Stream no longer available.");
+        }
+        else {
+            res.end();
+        }
+        return;
+    }
+    // Capture client address for client tracking. Captured before any async operations so it remains consistent in the cleanup closure, even if the request object
+    // becomes unreliable after disconnect.
+    const clientAddress = req.ip ?? req.socket.remoteAddress ?? "unknown";
+    // Increment the MPEG-TS client counter to prevent idle timeout while this client is connected.
+    stream.mpegTsClientCount++;
+    updateLastAccess(streamId);
+    registerClient(streamId, clientAddress, "mpegts");
+    const streamLog = LOG.withStreamId(stream.streamIdStr);
+    // Track which segments have been written to FFmpeg stdin to avoid duplicates during the catchup phase. When we subscribe to segment events and then write
+    // existing segments, a new segment could arrive via the event that we also encounter in the existing segment iteration. The Set prevents writing it twice.
+    const sentSegments = new Set();
+    let cleanedUp = false;
+    // We declare cleanup as a let initialized to a no-op so the error callback and stdin error handler can reference it before the real implementation is assigned. It
+    // is reassigned to the real cleanup function immediately after all handlers are defined, before any asynchronous events can fire.
+    let cleanup = () => { };
+    // Spawn an FFmpeg process to remux fMP4 to MPEG-TS. The process reads concatenated fMP4 (init segment + media segments) from stdin and outputs a continuous
+    // MPEG-TS stream on stdout. Video (H264) and audio (AAC) are copied without transcoding.
+    const remuxer = spawnMpegTsRemuxer((error) => {
+        streamLog.debug("streaming:mpegts", "MPEG-TS remuxer error: %s.", formatError(error));
+        cleanup();
+        if (!res.writableEnded) {
+            res.end();
+        }
+    }, stream.streamIdStr);
+    // Handler for new media segments. Writes each segment to FFmpeg stdin and updates the last access timestamp to prevent idle timeout.
+    const onSegment = (filename, data) => {
+        if (cleanedUp || sentSegments.has(filename)) {
+            return;
+        }
+        sentSegments.add(filename);
+        remuxer.stdin.write(data);
+        updateLastAccess(streamId);
+    };
+    // Handler for stream termination. Ends FFmpeg stdin gracefully so it can flush remaining data and exit cleanly.
+    const onTerminated = () => {
+        if (cleanedUp) {
+            return;
+        }
+        remuxer.stdin.end();
+    };
+    // Suppress errors from writing to a closed FFmpeg stdin. This can happen during cleanup when the capture stream closes before we stop writing.
+    remuxer.stdin.on("error", () => {
+        cleanup();
+    });
+    // Assign the real cleanup function. This is idempotent — the cleanedUp flag ensures it only runs once regardless of which event triggers it first (client
+    // disconnect, stream termination, or FFmpeg error).
+    cleanup = () => {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+        // Decrement the client counter. Re-read the stream from the registry since it may have been unregistered during stream termination.
+        const currentStream = getStream(streamId);
+        if (currentStream) {
+            currentStream.mpegTsClientCount = Math.max(0, currentStream.mpegTsClientCount - 1);
+            // When the last MPEG-TS client disconnects, reset the idle timer so the stream gets the standard idle timeout grace period before cleanup. This gives
+            // channel-surfing users time to switch back without the stream being torn down immediately.
+            if (currentStream.mpegTsClientCount === 0) {
+                updateLastAccess(streamId);
+            }
+        }
+        unregisterClient(streamId, clientAddress, "mpegts");
+        stream.hls.segmentEmitter.off("segment", onSegment);
+        stream.hls.segmentEmitter.off("terminated", onTerminated);
+        remuxer.kill();
+        streamLog.debug("streaming:mpegts", "MPEG-TS client disconnected.");
+    };
+    // Clean up when the client disconnects. Registered immediately after cleanup is assigned to minimize the window where a disconnect could be missed.
+    req.on("close", () => {
+        cleanup();
+    });
+    // Subscribe to segment events BEFORE writing existing segments to avoid missing any segments added during the catchup phase.
+    stream.hls.segmentEmitter.on("segment", onSegment);
+    stream.hls.segmentEmitter.on("terminated", onTerminated);
+    // Set response headers if they haven't been flushed yet (fast path for existing streams).
+    if (!res.headersSent) {
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "close");
+        res.setHeader("Content-Type", "video/mpeg");
+        res.setHeader("transferMode.dlna.org", "Streaming");
+    }
+    // Pipe FFmpeg stdout to the HTTP response. When FFmpeg exits (either from stdin ending or being killed), stdout closes and the response ends automatically.
+    remuxer.stdout.pipe(res);
+    // Write the init segment first — FFmpeg needs the ftyp and moov boxes before it can process any media segments.
+    remuxer.stdin.write(stream.hls.initSegment);
+    // Write all existing media segments to provide immediate playback catchup. The sentSegments Set deduplicates against any segments received via the event handler
+    // during this iteration.
+    for (const [filename, data] of stream.hls.segments) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (cleanedUp) {
+            break;
+        }
+        sentSegments.add(filename);
+        remuxer.stdin.write(data);
+    }
+    streamLog.debug("streaming:mpegts", "MPEG-TS client connected.");
+}
+//# sourceMappingURL=mpegts.js.map

package/dist/streaming/mpegts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpegts.js","sourceRoot":"","sources":["../../src/streaming/mpegts.ts"],"names":[],"mappings":"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"}

package/dist/streaming/registry.d.ts

@@ -0,0 +1,119 @@
+import type { Nullable, ResolvedSiteProfile } from "../types/index.js";
+import { EventEmitter } from "node:events";
+import type { FFmpegProcess } from "../utils/index.js";
+import type { FMP4SegmenterResult } from "./fmp4Segmenter.js";
+import type { Page } from "puppeteer-core";
+import type { Readable } from "node:stream";
+import type { RecoveryMetrics } from "./monitor.js";
+/**
+ * HLS segment and playlist storage for a stream. This includes the fMP4 initialization segment (codec configuration), media segments (.m4s files), and the current
+ * playlist content. The playlistReady promise allows callers to wait for the first playlist to be generated.
+ *
+ * Note: HLSState is co-located with the registry because it is part of StreamRegistryEntry. Moving it to hlsSegments.ts would create a circular dependency since
+ * hlsSegments.ts imports getStream from registry.ts.
+ */
+export interface HLSState {
+    initSegment: Nullable<Buffer>;
+    initSegmentReady: Promise<void>;
+    playlist: string;
+    playlistReady: Promise<void>;
+    segmentEmitter: EventEmitter;
+    segments: Map<string, Buffer>;
+    signalInitSegmentReady: () => void;
+    signalPlaylistReady: () => void;
+}
+/**
+ * Stream-specific information for idle detection.
+ */
+export interface StreamInfo {
+    lastPlaylistRequest: number;
+    storeKey: string;
+}
+/**
+ * Registry entry for an active stream. This is the single source of truth for all stream data, including browser state, HLS segments, and the segmenter reference.
+ */
+export interface StreamRegistryEntry {
+    channelName: Nullable<string>;
+    clientAddress: Nullable<string>;
+    ffmpegProcess: Nullable<FFmpegProcess>;
+    hls: HLSState;
+    id: number;
+    mpegTsClientCount: number;
+    info: StreamInfo;
+    page: Page;
+    profile: ResolvedSiteProfile;
+    rawCaptureStream: Nullable<Readable>;
+    segmenter: Nullable<FMP4SegmenterResult>;
+    startTime: Date;
+    stopMonitor: Nullable<() => RecoveryMetrics>;
+    streamIdStr: string;
+    url: string;
+}
+/**
+ * Gets the next unique stream ID by incrementing the counter. Each call returns a new, higher ID that has never been used before in this process lifetime.
+ * @returns The next unique stream ID.
+ */
+export declare function getNextStreamId(): number;
+/**
+ * Registers a stream in the registry. This should be called after stream setup is complete and the stream is ready to serve data.
+ * @param entry - The stream registry entry to add.
+ */
+export declare function registerStream(entry: StreamRegistryEntry): void;
+/**
+ * Unregisters a stream from the registry. This should be called during stream cleanup to remove the stream from tracking.
+ * @param id - The numeric stream ID to remove.
+ */
+export declare function unregisterStream(id: number): void;
+/**
+ * Gets a stream entry by its ID.
+ * @param id - The numeric stream ID to look up.
+ * @returns The stream entry if found, undefined otherwise.
+ */
+export declare function getStream(id: number): StreamRegistryEntry | undefined;
+/**
+ * Gets all stream entries in the registry.
+ * @returns Array of all stream registry entries.
+ */
+export declare function getAllStreams(): StreamRegistryEntry[];
+/**
+ * Gets the total number of streams in the registry.
+ * @returns The number of active streams.
+ */
+export declare function getStreamCount(): number;
+/**
+ * Updates the last playlist request timestamp for a stream. This should be called whenever a playlist or segment is requested to keep the idle timeout accurate.
+ * @param id - The numeric stream ID.
+ */
+export declare function updateLastAccess(id: number): void;
+/**
+ * Creates the initial HLS state for a new stream. This sets up empty segment storage and the playlist readiness signaling mechanism.
+ * @returns A new HLSState object ready to receive segments.
+ */
+export declare function createHLSState(): HLSState;
+/**
+ * Memory usage breakdown for a stream's HLS segment storage.
+ */
+export interface StreamMemoryUsage {
+    initSegment: number;
+    segments: number;
+    total: number;
+}
+/**
+ * Calculates the memory usage for a single stream's HLS segment storage. This measures the Buffer sizes of the init segment and all media segments currently retained
+ * in memory.
+ * @param entry - The stream registry entry to measure.
+ * @returns Memory usage breakdown in bytes.
+ */
+export declare function getStreamMemoryUsage(entry: StreamRegistryEntry): StreamMemoryUsage;
+/**
+ * Calculates the total segment memory usage across all active streams. This is useful for monitoring overall memory consumption by HLS buffers.
+ * @returns Total memory usage in bytes across all streams.
+ */
+export declare function getTotalSegmentMemory(): number;
+/**
+ * Gets the size in bytes of the last segment stored for a stream. Used by the monitor to detect dead capture pipelines that produce empty segments (18 bytes observed)
+ * while the video element appears healthy.
+ * @param entry - The stream registry entry to query.
+ * @returns Segment size in bytes, or null if no segmenter exists.
+ */
+export declare function getLastSegmentSize(entry: StreamRegistryEntry): Nullable<number>;

package/dist/streaming/registry.js

@@ -0,0 +1,127 @@
+import { EventEmitter } from "node:events";
+// State.
+// The unified stream registry. Maps numeric stream IDs to stream entries.
+const streamRegistry = new Map();
+// Counter for generating unique stream IDs. Incremented for each new stream.
+let streamIdCounter = 0;
+// Public API.
+/**
+ * Gets the next unique stream ID by incrementing the counter. Each call returns a new, higher ID that has never been used before in this process lifetime.
+ * @returns The next unique stream ID.
+ */
+export function getNextStreamId() {
+    return ++streamIdCounter;
+}
+/**
+ * Registers a stream in the registry. This should be called after stream setup is complete and the stream is ready to serve data.
+ * @param entry - The stream registry entry to add.
+ */
+export function registerStream(entry) {
+    streamRegistry.set(entry.id, entry);
+}
+/**
+ * Unregisters a stream from the registry. This should be called during stream cleanup to remove the stream from tracking.
+ * @param id - The numeric stream ID to remove.
+ */
+export function unregisterStream(id) {
+    streamRegistry.delete(id);
+}
+/**
+ * Gets a stream entry by its ID.
+ * @param id - The numeric stream ID to look up.
+ * @returns The stream entry if found, undefined otherwise.
+ */
+export function getStream(id) {
+    return streamRegistry.get(id);
+}
+/**
+ * Gets all stream entries in the registry.
+ * @returns Array of all stream registry entries.
+ */
+export function getAllStreams() {
+    return Array.from(streamRegistry.values());
+}
+/**
+ * Gets the total number of streams in the registry.
+ * @returns The number of active streams.
+ */
+export function getStreamCount() {
+    return streamRegistry.size;
+}
+/**
+ * Updates the last playlist request timestamp for a stream. This should be called whenever a playlist or segment is requested to keep the idle timeout accurate.
+ * @param id - The numeric stream ID.
+ */
+export function updateLastAccess(id) {
+    const entry = streamRegistry.get(id);
+    if (entry) {
+        entry.info.lastPlaylistRequest = Date.now();
+    }
+}
+/**
+ * Creates the initial HLS state for a new stream. This sets up empty segment storage and the playlist readiness signaling mechanism.
+ * @returns A new HLSState object ready to receive segments.
+ */
+export function createHLSState() {
+    let signalInitSegmentReady = () => { };
+    let signalPlaylistReady = () => { };
+    const initSegmentReady = new Promise((resolve) => {
+        signalInitSegmentReady = resolve;
+    });
+    const playlistReady = new Promise((resolve) => {
+        signalPlaylistReady = resolve;
+    });
+    const segmentEmitter = new EventEmitter();
+    // Allow up to 20 listeners per event to support multiple concurrent MPEG-TS clients consuming the same stream.
+    segmentEmitter.setMaxListeners(20);
+    return {
+        initSegment: null,
+        initSegmentReady,
+        playlist: "",
+        playlistReady,
+        segmentEmitter,
+        segments: new Map(),
+        signalInitSegmentReady,
+        signalPlaylistReady
+    };
+}
+/**
+ * Calculates the memory usage for a single stream's HLS segment storage. This measures the Buffer sizes of the init segment and all media segments currently retained
+ * in memory.
+ * @param entry - The stream registry entry to measure.
+ * @returns Memory usage breakdown in bytes.
+ */
+export function getStreamMemoryUsage(entry) {
+    const initSegmentSize = entry.hls.initSegment?.length ?? 0;
+    let segmentsSize = 0;
+    for (const segment of entry.hls.segments.values()) {
+        segmentsSize += segment.length;
+    }
+    return {
+        initSegment: initSegmentSize,
+        segments: segmentsSize,
+        total: initSegmentSize + segmentsSize
+    };
+}
+/**
+ * Calculates the total segment memory usage across all active streams. This is useful for monitoring overall memory consumption by HLS buffers.
+ * @returns Total memory usage in bytes across all streams.
+ */
+export function getTotalSegmentMemory() {
+    let total = 0;
+    for (const entry of streamRegistry.values()) {
+        total += getStreamMemoryUsage(entry).total;
+    }
+    return total;
+}
+// Segment Health.
+/**
+ * Gets the size in bytes of the last segment stored for a stream. Used by the monitor to detect dead capture pipelines that produce empty segments (18 bytes observed)
+ * while the video element appears healthy.
+ * @param entry - The stream registry entry to query.
+ * @returns Segment size in bytes, or null if no segmenter exists.
+ */
+export function getLastSegmentSize(entry) {
+    return entry.segmenter?.getLastSegmentSize() ?? null;
+}
+//# sourceMappingURL=registry.js.map

package/dist/streaming/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/streaming/registry.ts"],"names":[],"mappings":"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"}

package/dist/streaming/setup.d.ts

@@ -0,0 +1,135 @@
+import type { Channel, Nullable, ResolvedSiteProfile, UrlValidation } from "../types/index.js";
+import type { Frame, Page } from "puppeteer-core";
+import type { RecoveryMetrics, TabReplacementResult } from "./monitor.js";
+import type { FFmpegProcess } from "../utils/index.js";
+import type { Readable } from "node:stream";
+/**
+ * Factory function type for creating tab replacement handlers. Called by setupStream after generating stream IDs and resolving the profile, allowing the caller to
+ * create a handler with access to all necessary context.
+ */
+export type TabReplacementHandlerFactory = (numericStreamId: number, streamId: string, profile: ResolvedSiteProfile, metadataComment: string | undefined) => () => Promise<Nullable<TabReplacementResult>>;
+/**
+ * Options for setting up a stream.
+ */
+export interface StreamSetupOptions {
+    channel?: Channel;
+    channelName?: string;
+    channelSelector?: string;
+    clickSelector?: string;
+    clickToPlay?: boolean;
+    noVideo?: boolean;
+    onTabReplacementFactory?: TabReplacementHandlerFactory;
+    profileOverride?: string;
+    url: string;
+}
+/**
+ * Result from setting up a stream.
+ */
+export interface StreamSetupResult {
+    captureStream: Readable;
+    channelName: Nullable<string>;
+    cleanup: () => Promise<void>;
+    ffmpegProcess: Nullable<FFmpegProcess>;
+    numericStreamId: number;
+    page: Page;
+    profile: ResolvedSiteProfile;
+    profileName: string;
+    providerName: string;
+    rawCaptureStream: Readable;
+    startTime: Date;
+    stopMonitor: () => RecoveryMetrics;
+    streamId: string;
+    url: string;
+}
+/**
+ * Error thrown when stream setup fails. Includes HTTP status code and user-friendly message for the response.
+ */
+export declare class StreamSetupError extends Error {
+    readonly statusCode: number;
+    readonly userMessage: string;
+    constructor(message: string, statusCode: number, userMessage: string);
+}
+/**
+ * Options for creating a page with capture.
+ */
+export interface CreatePageWithCaptureOptions {
+    comment?: string;
+    onFFmpegError?: (error: Error) => void;
+    profile: ResolvedSiteProfile;
+    streamId: string;
+    url: string;
+    _pageClosedRetries?: number;
+}
+/**
+ * Result from creating a page with capture. Contains everything needed to create a segmenter and continue with stream setup.
+ */
+export interface CreatePageWithCaptureResult {
+    captureStream: Readable;
+    context: Frame | Page;
+    ffmpegProcess: Nullable<FFmpegProcess>;
+    page: Page;
+    rawCaptureStream: Readable;
+}
+/**
+ * Generates a concise stream identifier for logging purposes. The identifier combines the channel name or hostname with a unique request ID, making it easy to
+ * trace related log messages. We prefer the channel name when available because it's more meaningful than a hostname.
+ * @param channelName - The channel name if streaming a named channel.
+ * @param url - The URL being streamed.
+ * @returns A concise stream identifier.
+ */
+export declare function generateStreamId(channelName: string | undefined, url: string | undefined): string;
+/**
+ * Validates a URL before attempting to navigate to it. This function checks for supported protocols, prevents local file access, and ensures the URL is properly
+ * formatted. Validating URLs before navigation prevents security issues and provides clear error messages.
+ * @param url - The URL to validate.
+ * @returns Validation result with optional reason for failure.
+ */
+export declare function validateStreamUrl(url: string | undefined): UrlValidation;
+/**
+ * Creates a browser page with media capture and navigates to the URL. This is the reusable core function used by both initial stream setup and tab replacement
+ * recovery. It handles:
+ * - Creating a new browser page with CSP bypass
+ * - Initializing media capture (native fMP4 or WebM+FFmpeg)
+ * - Navigating to the URL with retry
+ * - Setting up video playback via navigateToPage() + initializePlayback()
+ *
+ * The caller is responsible for:
+ * - Creating the segmenter and piping captureStream to it
+ * - Registering/updating the stream in the registry
+ * - Starting/updating the health monitor
+ * - Handling cleanup on failure
+ *
+ * @param options - Options for page and capture creation.
+ * @returns The page, context, capture stream, and FFmpeg process (if any).
+ * @throws Error if page creation, capture initialization, or navigation fails.
+ */
+export declare function createPageWithCapture(options: CreatePageWithCaptureOptions): Promise<CreatePageWithCaptureResult>;
+/**
+ * Sets up a stream: validates input, creates browser page, initializes capture, navigates to URL, and starts health monitoring.
+ *
+ * This function handles all common stream setup logic. The caller is responsible for:
+ * - Connecting the returned captureStream to the appropriate output (HTTP response, FFmpeg, etc.)
+ * - Registering the stream in the registry
+ * - Triggering cleanup when the stream ends
+ *
+ * @param options - Stream configuration options.
+ * @param onCircuitBreak - Callback invoked when the circuit breaker trips (stream unrecoverable).
+ * @returns Setup result with capture stream, cleanup function, and metadata.
+ * @throws StreamSetupError if setup fails with appropriate status code and message.
+ */
+export declare function setupStream(options: StreamSetupOptions, onCircuitBreak: () => void): Promise<StreamSetupResult>;
+/**
+ * Verifies that Chrome's capture system is functional before the server starts accepting requests. This detects stale tabCapture state left over from a previous
+ * Chrome process — common during quick service restarts where the old process hasn't fully exited before the new one launches. Without this probe, the first stream
+ * request would trigger the runtime stale capture handler, which exits the process because the puppeteer-stream mutex is permanently leaked.
+ *
+ * The probe creates a temporary page, attempts a short capture, and tears down both cleanly. A 500ms delay after destroying the capture stream allows
+ * puppeteer-stream's fire-and-forget STOP_RECORDING chain to complete before closing the page, preventing the stale capture cascade on the first real request.
+ *
+ * After a system reboot, Chrome's display stack or capture extension may not be ready when the service manager starts PrismCast. The probe retries up to
+ * PROBE_MAX_ATTEMPTS times with a delay between attempts, giving the system time to settle before giving up. This prevents a rapid restart storm where the service
+ * manager relaunches PrismCast repeatedly, each attempt orphaning a Chrome process and degrading the environment further.
+ *
+ * If stale capture state is detected, the process exits immediately — Chrome restart cannot fix the leaked mutex, only a fresh process can.
+ */
+export declare function verifyCaptureSystem(): Promise<void>;