prismcast 1.12.0 → 1.13.0

package/dist/streaming/registry.d.ts

@@ -1,12 +1,14 @@
-import type { MediaContainer, Nullable, ResolvedSiteProfile, StreamingMode } from "../types/index.ts";
+import type { MediaContainer, Nullable, ResolvedSiteProfile } from "../types/index.ts";
 import type { CaptureCodec } from "./codec.ts";
 import type { CaptureSession } from "./captureSession.ts";
 import { EventEmitter } from "node:events";
+import type { FMP4SegmenterResult } from "./fmp4Segmenter.ts";
 import type { ManifestInterceptionResult } from "../browser/manifestInterceptor.ts";
 import type { MonitorHandle } from "./recovery.ts";
 import type { NativeProxy } from "../native/proxy.ts";
 import type { Page } from "puppeteer-core";
 import type { ProbeCacheIdentity } from "../native/probe.ts";
+import type { RefreshedFeedMetadata } from "../native/index.ts";
 /**
  * Typed event map for segment notifications. MPEG-TS consumers and lifecycle handlers subscribe to these events. Using a typed interface ensures event names and
  * argument types are checked at compile time, preventing misspelled event names or incorrect payloads.
@@ -30,6 +32,13 @@ export interface SegmentEmitter extends EventEmitter {
  * signature names the type rather than restating the literal pair.
  */
 export type InitSegmentTrack = "audio" | "video";
+/**
+ * The HTTP status and user-facing message a failed stream setup answers its clients with.
+ */
+export interface SetupFailureStatus {
+    readonly statusCode: number;
+    readonly userMessage: string;
+}
 /**
  * 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.
@@ -59,9 +68,10 @@ export interface HLSState {
     prerollBaseUrl: Nullable<string>;
     prerollCodec: Nullable<CaptureCodec>;
     prerollSegmentCount: number;
-    prerollStartTime: Nullable<Date>;
-    prerollTimer: Nullable<ReturnType<typeof setTimeout>>;
+    prerollStartTime: Nullable<number>;
+    prerollTimer: Nullable<Disposable>;
     resumeSegmentIndex: number;
+    setupFailure: Nullable<SetupFailureStatus>;
 }
 /**
  * Stream-specific information for idle detection.
@@ -70,32 +80,46 @@ export interface StreamInfo {
     lastPlaylistRequest: number;
     storeKey: string;
 }
+/**
+ * The identity of a capture-mode stream: the screen-capture pipeline and the encoder facts that describe what it is producing.
+ */
+export interface CaptureStreamIdentity {
+    readonly captureCodec: Nullable<string>;
+    readonly captureSession: Nullable<CaptureSession>;
+    readonly hardwareAccelerated: boolean;
+    readonly mode: "capture";
+}
+/**
+ * The identity of a native-mode stream: the HLS proxy relaying the service's own segments, and the manifest facts that describe the feed it is bound to.
+ */
+export interface NativeStreamIdentity {
+    readonly captureCodec: Nullable<string>;
+    readonly mode: "native";
+    readonly nativeBandwidth: number;
+    readonly nativeContainer: Nullable<MediaContainer>;
+    readonly nativeProxy: NativeProxy;
+    readonly nativeResolution: Nullable<string>;
+    readonly reestablishManifest: (page: Page) => Promise<Nullable<ManifestInterceptionResult>>;
+}
+export type StreamIdentity = CaptureStreamIdentity | NativeStreamIdentity;
 /**
  * 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 {
-    captureCodec: Nullable<string>;
-    captureSession: Nullable<CaptureSession>;
     channelName: Nullable<string>;
     clientAddress: Nullable<string>;
-    hardwareAccelerated: boolean;
     hls: HLSState;
     id: number;
+    identity: StreamIdentity;
     mpegTsClientCount: number;
-    nativeBandwidth: number;
-    nativeContainer: Nullable<MediaContainer>;
-    nativeProxy: Nullable<NativeProxy>;
-    nativeResolution: Nullable<string>;
     info: StreamInfo;
     page: Nullable<Page>;
     preTuned: boolean;
     probeIdentity: Nullable<ProbeCacheIdentity>;
     profile: Nullable<ResolvedSiteProfile>;
-    reestablishManifest: Nullable<(page: Page) => Promise<Nullable<ManifestInterceptionResult>>>;
-    startTime: Date;
+    startTime: number;
     monitor: Nullable<MonitorHandle>;
     streamIdStr: string;
-    streamingMode: StreamingMode;
     url: string;
 }
 /**
@@ -129,11 +153,65 @@ export declare function getAllStreams(): StreamRegistryEntry[];
  * @returns The number of active streams.
  */
 export declare function getStreamCount(): number;
+/**
+ * Reports whether any registered stream is in capture mode. The browser window's visibility policy reads this, so it is evaluated fresh on every call - the answer
+ * flips with every stream start and end, and a cached copy would be stale exactly when it matters.
+ *
+ * Registry presence is the test rather than a live captureSession reference. A pending entry registers in capture mode before physical capture starts, and an entry
+ * leaves the registry only after teardown, so membership brackets the entire window during which Chrome is reading the compositor. The capture session attaches
+ * partway through establishment, which would leave the predicate reading false across the whole tune - the moment the window most needs to be visible.
+ * @returns True when at least one registered stream is in capture mode.
+ */
+export declare function hasActiveCaptureStreams(): boolean;
+/**
+ * Reports whether any registered stream has been established on the browser. A stream is established once its entry holds its page, in either mode - a capture
+ * reads that page's compositor output and a native relay keeps its page for re-establishment - and from that moment it depends on the browser the page lives in.
+ * A pending entry holds no page, so a tune that has released its page to wait on a relaunch does not count itself among the reasons that relaunch cannot run.
+ *
+ * It is deliberately narrower than hasActiveCaptureStreams beside it, which counts pending entries on purpose: the window has to be on screen for the whole tune,
+ * whereas the question here is what a browser teardown would destroy.
+ * @returns True when at least one registered stream holds a page.
+ */
+export declare function hasEstablishedStreams(): boolean;
+/**
+ * Builds the identity a stream is born with: capture mode, with no pipeline and no encoder facts yet. The literal exists here alone so the pending birth and the
+ * native fallback's pre-flip declare the same shape rather than hand-copying it.
+ * @returns A capture identity in its pending state.
+ */
+export declare function makePendingCaptureIdentity(): CaptureStreamIdentity;
+/**
+ * Narrows a stream entry to capture mode. Published alongside the segment-health readers so consumers outside the streaming layer ask the registry what a stream
+ * is rather than reaching into its identity themselves.
+ * @param entry - The stream registry entry to test.
+ * @returns True when the entry carries a capture identity, narrowing it for the caller.
+ */
+export declare function isCaptureIdentity(entry: StreamRegistryEntry): entry is StreamRegistryEntry & {
+    identity: CaptureStreamIdentity;
+};
+/**
+ * Reports whether a stream is encoding on the local GPU. Hardware acceleration is a capture-mode fact, so native streams answer false: they pass the service's own
+ * segments through and encode nothing locally. The status projections read it here rather than each narrowing the identity themselves.
+ * @param entry - The stream registry entry to query.
+ * @returns True when the stream is capturing with hardware-accelerated encoding.
+ */
+export declare function isHardwareAccelerated(entry: StreamRegistryEntry): boolean;
+/**
+ * Records the quality a token refresh has bound this stream to. The registry owns the mechanics because two layers relay the same refresh - the native upgrade in
+ * hls.ts and the monitor's L2 recovery - and a hand-copied guard-then-spread in each would be two chances to get it wrong.
+ *
+ * The narrow happens here, freshly, because both callers invoke this from an asynchronous callback that can fire long after any earlier check: a refresh that
+ * completes while a capture fallback is mid-flight finds a capture identity and is skipped. Skipping is right in every case - quality metadata for a stream
+ * midway through a fallback is moot, and a fallback that fails restores the proxy, whose next refresh writes the quality again.
+ * @param entry - The stream registry entry to update.
+ * @param refreshed - The quality facts of the freshly bound feed.
+ */
+export declare function applyNativeQualityRefresh(entry: StreamRegistryEntry, refreshed: RefreshedFeedMetadata): void;
 /**
  * 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.
+ * @param now - The instant of the request.
  */
-export declare function updateLastAccess(id: number): void;
+export declare function updateLastAccess(id: number, now: 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.
@@ -167,6 +245,16 @@ export declare function getStreamMemoryUsage(entry: StreamRegistryEntry): Stream
  * @returns Total memory usage in bytes across all streams.
  */
 export declare function getTotalSegmentMemory(): number;
+/**
+ * Returns the fMP4 segmenter producing a stream's segments, or null when there is none: a native stream relays the service's own segments, and a capture stream
+ * has no segmenter until createCaptureSegmenter wires one. This is the single place the capture-identity narrow and the pipeline walk are written, so the several
+ * consumers that read segment indices, init segments, and session statistics all ask the same question the same way.
+ *
+ * An absent entry is accepted because callers routinely look the stream up and read its segmenter in one expression; a stream that is gone has no segmenter.
+ * @param entry - The stream registry entry to query, or undefined when the lookup found nothing.
+ * @returns The attached segmenter, or null.
+ */
+export declare function getStreamSegmenter(entry: StreamRegistryEntry | undefined): Nullable<FMP4SegmenterResult>;
 /**
  * Returns whether the last segment contained video traf boxes. Used by the monitor to distinguish dead capture pipelines (audio-only, no video trafs) from legitimate
  * small segments produced by static content (video trafs present but low-bitrate). Returns null if the segmenter does not exist or the video trackId is unknown.
@@ -182,4 +270,3 @@ export declare function getLastSegmentHasVideo(entry: StreamRegistryEntry): Null
  */
 export declare function getLastSegmentSize(entry: StreamRegistryEntry): Nullable<number>;
 export {};
-//# sourceMappingURL=registry.d.ts.map

package/dist/streaming/registry.js

@@ -48,14 +48,83 @@ export function getAllStreams() {
 export function getStreamCount() {
     return streamRegistry.size;
 }
+/**
+ * Reports whether any registered stream is in capture mode. The browser window's visibility policy reads this, so it is evaluated fresh on every call - the answer
+ * flips with every stream start and end, and a cached copy would be stale exactly when it matters.
+ *
+ * Registry presence is the test rather than a live captureSession reference. A pending entry registers in capture mode before physical capture starts, and an entry
+ * leaves the registry only after teardown, so membership brackets the entire window during which Chrome is reading the compositor. The capture session attaches
+ * partway through establishment, which would leave the predicate reading false across the whole tune - the moment the window most needs to be visible.
+ * @returns True when at least one registered stream is in capture mode.
+ */
+export function hasActiveCaptureStreams() {
+    return getAllStreams().some(isCaptureIdentity);
+}
+/**
+ * Reports whether any registered stream has been established on the browser. A stream is established once its entry holds its page, in either mode - a capture
+ * reads that page's compositor output and a native relay keeps its page for re-establishment - and from that moment it depends on the browser the page lives in.
+ * A pending entry holds no page, so a tune that has released its page to wait on a relaunch does not count itself among the reasons that relaunch cannot run.
+ *
+ * It is deliberately narrower than hasActiveCaptureStreams beside it, which counts pending entries on purpose: the window has to be on screen for the whole tune,
+ * whereas the question here is what a browser teardown would destroy.
+ * @returns True when at least one registered stream holds a page.
+ */
+export function hasEstablishedStreams() {
+    return getAllStreams().some((entry) => entry.page !== null);
+}
+// Identity.
+/**
+ * Builds the identity a stream is born with: capture mode, with no pipeline and no encoder facts yet. The literal exists here alone so the pending birth and the
+ * native fallback's pre-flip declare the same shape rather than hand-copying it.
+ * @returns A capture identity in its pending state.
+ */
+export function makePendingCaptureIdentity() {
+    return { captureCodec: null, captureSession: null, hardwareAccelerated: false, mode: "capture" };
+}
+/**
+ * Narrows a stream entry to capture mode. Published alongside the segment-health readers so consumers outside the streaming layer ask the registry what a stream
+ * is rather than reaching into its identity themselves.
+ * @param entry - The stream registry entry to test.
+ * @returns True when the entry carries a capture identity, narrowing it for the caller.
+ */
+export function isCaptureIdentity(entry) {
+    return entry.identity.mode === "capture";
+}
+/**
+ * Reports whether a stream is encoding on the local GPU. Hardware acceleration is a capture-mode fact, so native streams answer false: they pass the service's own
+ * segments through and encode nothing locally. The status projections read it here rather than each narrowing the identity themselves.
+ * @param entry - The stream registry entry to query.
+ * @returns True when the stream is capturing with hardware-accelerated encoding.
+ */
+export function isHardwareAccelerated(entry) {
+    return (entry.identity.mode === "capture") && entry.identity.hardwareAccelerated;
+}
+/**
+ * Records the quality a token refresh has bound this stream to. The registry owns the mechanics because two layers relay the same refresh - the native upgrade in
+ * hls.ts and the monitor's L2 recovery - and a hand-copied guard-then-spread in each would be two chances to get it wrong.
+ *
+ * The narrow happens here, freshly, because both callers invoke this from an asynchronous callback that can fire long after any earlier check: a refresh that
+ * completes while a capture fallback is mid-flight finds a capture identity and is skipped. Skipping is right in every case - quality metadata for a stream
+ * midway through a fallback is moot, and a fallback that fails restores the proxy, whose next refresh writes the quality again.
+ * @param entry - The stream registry entry to update.
+ * @param refreshed - The quality facts of the freshly bound feed.
+ */
+export function applyNativeQualityRefresh(entry, refreshed) {
+    const identity = entry.identity;
+    if (identity.mode !== "native") {
+        return;
+    }
+    entry.identity = { ...identity, captureCodec: refreshed.codec, nativeBandwidth: refreshed.bandwidth, nativeResolution: refreshed.resolution };
+}
 /**
  * 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.
+ * @param now - The instant of the request.
  */
-export function updateLastAccess(id) {
+export function updateLastAccess(id, now) {
     const entry = streamRegistry.get(id);
     if (entry) {
-        entry.info.lastPlaylistRequest = Date.now();
+        entry.info.lastPlaylistRequest = now;
     }
 }
 /**
@@ -92,6 +161,7 @@ export function createHLSState() {
         segmentBytes: 0,
         segmentEmitter,
         segments: new Map(),
+        setupFailure: null,
         signalInitSegmentReady,
         signalPlaylistReady,
         videoPlaylist: ""
@@ -106,7 +176,7 @@ export function createHLSState() {
  */
 export function cancelPrerollTimer(hls) {
     if (hls.prerollTimer) {
-        clearTimeout(hls.prerollTimer);
+        hls.prerollTimer[Symbol.dispose]();
         hls.prerollTimer = null;
     }
 }
@@ -139,6 +209,21 @@ export function getTotalSegmentMemory() {
     return total;
 }
 // Segment Health.
+/**
+ * Returns the fMP4 segmenter producing a stream's segments, or null when there is none: a native stream relays the service's own segments, and a capture stream
+ * has no segmenter until createCaptureSegmenter wires one. This is the single place the capture-identity narrow and the pipeline walk are written, so the several
+ * consumers that read segment indices, init segments, and session statistics all ask the same question the same way.
+ *
+ * An absent entry is accepted because callers routinely look the stream up and read its segmenter in one expression; a stream that is gone has no segmenter.
+ * @param entry - The stream registry entry to query, or undefined when the lookup found nothing.
+ * @returns The attached segmenter, or null.
+ */
+export function getStreamSegmenter(entry) {
+    if (entry?.identity.mode !== "capture") {
+        return null;
+    }
+    return entry.identity.captureSession?.segmenter ?? null;
+}
 /**
  * Returns whether the last segment contained video traf boxes. Used by the monitor to distinguish dead capture pipelines (audio-only, no video trafs) from legitimate
  * small segments produced by static content (video trafs present but low-bitrate). Returns null if the segmenter does not exist or the video trackId is unknown.
@@ -146,7 +231,7 @@ export function getTotalSegmentMemory() {
  * @returns True if video trafs were present, false if absent, null if unknown.
  */
 export function getLastSegmentHasVideo(entry) {
-    return entry.captureSession?.segmenter?.getLastSegmentHasVideo() ?? null;
+    return getStreamSegmenter(entry)?.getLastSegmentHasVideo() ?? null;
 }
 /**
  * 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)
@@ -155,6 +240,6 @@ export function getLastSegmentHasVideo(entry) {
  * @returns Segment size in bytes, or null if no segmenter exists.
  */
 export function getLastSegmentSize(entry) {
-    return entry.captureSession?.segmenter?.getLastSegmentSize() ?? null;
+    return getStreamSegmenter(entry)?.getLastSegmentSize() ?? null;
 }
 //# sourceMappingURL=registry.js.map

package/dist/streaming/registry.js.map

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

package/dist/streaming/setup.d.ts

@@ -1,15 +1,33 @@
 import type { Browser, Frame, Page } from "puppeteer-core";
-import { getCurrentBrowser, getStream } from "../browser/index.ts";
+import { acquireCaptureStream, emulateCaptureSurface, getBrowserInstance, getCaptureImpairment, getCurrentBrowser, installActivationHeal, noteBrowserCaptureImpaired, syncWindowVisibility } from "../browser/index.ts";
+import type { CaptureStream } from "../browser/index.ts";
+import { spawnFFmpeg } from "../utils/index.ts";
 import type { ManifestInterceptionResult, ManifestInterceptorHandle } from "../browser/manifestInterceptor.ts";
 import type { MonitorHandle, TabReplacementResult } from "./recovery.ts";
 import type { Nullable, ResolvedChannel, ResolvedSiteProfile, TuneResult, UrlValidationResult } from "../types/index.ts";
 import { initializePlayback } from "../browser/video.ts";
 import type { CaptureSession } from "./captureSession.ts";
+import type { Clock } from "homebridge-plugin-utils";
 import type { InitializePlaybackOptions } from "../browser/video.ts";
 import type { ProbeCacheIdentity } from "../native/probe.ts";
+import { openSharedWindowTab } from "../browser/tabSelection.ts";
+import { reaffirmCaptureSurface } from "../browser/cdp.ts";
 import { startOverlayHandling } from "../browser/consent.ts";
 export declare const STREAM_INIT_TIMEOUT_MESSAGE = "Stream initialization timed out.";
 export declare const CAPTURE_PROBE_TIMEOUT_MESSAGE = "Capture probe timed out.";
+/**
+ * Retires a raw capture stream: destroys it so the stop request goes out while the browser is still connected, then waits for the extension to confirm the
+ * recording stopped before the caller closes the page. This is the destroy-and-confirm core shared by the mid-life probe's success teardown and every path that
+ * must retire a capture stream produced after its caller had already abandoned the turn. It is the async sibling of captureSession.ts's disposer, which tears the
+ * composed FFmpeg pipeline down synchronously: this helper awaits the confirmation because a page close follows it directly, and unlike the composed disposer it
+ * is used on abandoned paths where the page may already be closed, so the stop side is then best-effort.
+ *
+ * It never throws. A confirmation that does not arrive inside the ceiling is warned about and then stepped past, because holding a page open for a browser that
+ * has stopped answering helps nobody.
+ * @param stream - The raw capture stream to retire.
+ * @param clock - Clock bounding the stop confirmation. Defaults to the system clock; tests inject a virtual clock.
+ */
+export declare function retireRawStream(stream: CaptureStream, clock?: Clock): Promise<void>;
 /**
  * Thrown by createPageWithCapture when an establishment that navigated to a resolved direct watch URL failed on evidence against that URL - the coordinator's own
  * verdict, read from invalidateDirectUrl, never re-derived here. It says one thing to the caller: the hint has already been evicted, and a fresh attempt down the
@@ -56,7 +74,7 @@ export interface StreamSetupResult {
     profile: ResolvedSiteProfile;
     profileName: string;
     serviceName: string;
-    startTime: Date;
+    startTime: number;
     monitor: MonitorHandle;
     streamId: string;
     url: string;
@@ -87,7 +105,6 @@ export declare function withSignInGuidance(userMessage: string, channelKey: Null
  */
 export interface CreatePageWithCaptureOptions {
     comment?: string;
-    numericStreamId: number;
     onFFmpegError?: (error: Error) => void;
     persistResolution?: (resolvedSelector: string) => Promise<void>;
     profile: ResolvedSiteProfile;
@@ -97,6 +114,7 @@ export interface CreatePageWithCaptureOptions {
     tabReplacement?: boolean;
     url: string;
     _pageClosedRetries?: number;
+    _refusalRetried?: boolean;
 }
 /**
  * Result from creating a page with capture. Contains everything needed to create a segmenter and continue with stream setup.
@@ -124,9 +142,16 @@ export declare function generateStreamId(channelName: string | undefined, url: s
  */
 export declare function validateStreamUrl(url: string | undefined): UrlValidationResult;
 export interface CreatePageWithCaptureDeps {
+    readonly acquireCaptureStream: typeof acquireCaptureStream;
+    readonly awaitCaptureVerdict: (error: unknown) => Promise<Nullable<CaptureProbeOutcome>>;
+    readonly emulateCaptureSurface: typeof emulateCaptureSurface;
     readonly getCurrentBrowser: typeof getCurrentBrowser;
-    readonly getStream: typeof getStream;
+    readonly installActivationHeal: typeof installActivationHeal;
+    readonly openSharedWindowTab: typeof openSharedWindowTab;
+    readonly reaffirmCaptureSurface: typeof reaffirmCaptureSurface;
+    readonly spawnFFmpeg: typeof spawnFFmpeg;
     readonly startOverlayHandling: typeof startOverlayHandling;
+    readonly syncWindowVisibility: typeof syncWindowVisibility;
 }
 /**
  * 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
@@ -135,6 +160,8 @@ export interface CreatePageWithCaptureDeps {
  * - Initializing media capture (native fMP4 or Matroska+FFmpeg)
  * - Navigating to the URL with retry
  * - Setting up video playback via navigateToPage() + initializePlayback()
+ * - Re-entering itself once, on a fresh page through a freshly acquired browser, when Chrome refuses the capture start and the mid-life probe's verdict says a
+ *   second attempt has something to start from
  *
  * The caller is responsible for:
  * - Creating the segmenter and attaching it to the capture session via captureSession.attachSegmenter()
@@ -144,7 +171,7 @@ export interface CreatePageWithCaptureDeps {
  *
  * @param options - Options for page and capture creation.
  * @param deps - The injected browser and overlay-poll collaborators; defaults to defaultCreatePageWithCaptureDeps. Threaded so a test drives this function without a
- * live Chrome by substituting the shared-browser accessor, the capture launcher, and the static-capture overlay poll.
+ * live Chrome by substituting the shared-browser accessor, the capture acquisition, and the static-capture overlay poll.
  * @returns The page, context, and capture session (which owns the raw capture stream and any FFmpeg child).
  * @throws Error if page creation, capture initialization, or navigation fails.
  */
@@ -195,7 +222,7 @@ export interface EstablishChannelPlaybackOptions {
  */
 export declare function establishChannelPlayback(page: Page, profile: ResolvedSiteProfile, handle: Nullable<ManifestInterceptorHandle>, options: EstablishChannelPlaybackOptions, deps?: EstablishChannelPlaybackDeps): Promise<TuneResult>;
 /**
- * Adjudicates what an establishment's interception selected: finalize it against the honest direct-tune kind, then confirm the manifest belongs to the channel
+ * Adjudicates what an establishment's interception selected: finalize it against the accurate direct-tune kind, then confirm the manifest belongs to the channel
  * the profile names. The tune path and the native refresh capability both run this, so finalize-then-verify is written exactly once.
  *
  * The stage hands on the interception promise rather than a resolved result, which is what keeps verifyManifestSelection's latency rule holding - its provider
@@ -235,39 +262,70 @@ export interface ReestablishChannelManifestOptions {
 }
 export declare function reestablishChannelManifest(options: ReestablishChannelManifestOptions): Promise<Nullable<ManifestInterceptionResult>>;
 /**
- * Verifies that a freshly-launched Chrome instance can actually capture, by running a real getStream against a throwaway page on it. This is the capability tier of
- * the browser launch gate: browser/index.ts injects it via setCaptureProbe and runs it inside launchReadyBrowser, so a browser is published as ready only after its
- * capture capability is verified - at boot AND at every relaunch, not just startup. It exercises the exact getStream path that hangs when the puppeteer-stream
- * extension is unregistered, so a dead extension is detected immediately rather than causing every subsequent stream request to hang.
+ * Verifies that a freshly-launched Chrome instance can actually capture, by running a real capture acquisition against a throwaway page on it. This is the
+ * capability tier of the browser launch gate: browser/index.ts injects it via setCaptureProbe and runs it inside launchReadyBrowser, so a browser is published as
+ * ready only after its capture capability is verified - at boot AND at every relaunch, not just startup. It exercises the exact acquisition path that fails when
+ * the capture extension is unregistered, so a dead extension is detected immediately rather than causing every subsequent stream request to fail.
  *
- * Each attempt 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 a stale capture cascade on the first real request.
+ * Each attempt creates a temporary page, attempts a short capture, and tears down both cleanly. The teardown waits for the extension to confirm the recording
+ * stopped, bounded by a ceiling, before closing the page, so Chrome's tabCapture state is released rather than lingering into the first real request.
  *
  * After a system reboot or a fresh relaunch, Chrome's display stack or capture extension may not be ready immediately. The probe retries up to PROBE_MAX_ATTEMPTS
  * times with a delay between attempts, giving the system time to settle before giving up. At boot this prevents a rapid restart storm where the service manager
  * relaunches PrismCast repeatedly, each attempt orphaning a Chrome process; at relaunch it provides in-launch settling before the supervisor counts a launch failure.
- *
- * If stale capture state is detected, the process exits immediately - a Chrome restart cannot fix the leaked module-level mutex, only a fresh process can.
  * @param browser - The Chrome instance to verify (the local instance being launched, passed in rather than re-acquired to avoid re-entering the launch in flight).
  */
 export declare function verifyCaptureSystem(browser: Browser): Promise<void>;
 /**
- * Pure decision for whether a mid-life capture-infrastructure failure warrants re-verifying the browser. Re-verification is warranted iff no other re-verification
- * is already in flight, a browser is published to probe, and the failing stream is the only active stream - any other active stream means either the browser is
- * demonstrably capturing (so this failure is stream-specific - never invalidate) or those streams will trip their own circuit breakers and drain, after which a
- * later failure reaches the zero-other case. An empty registry (setup failed before the stream was registered) satisfies the isolation check vacuously and is the
- * common real-world shape of this failure.
- * @param inputs - The decision inputs.
- * @param inputs.activeStreamIds - The ids of every stream currently in the registry.
- * @param inputs.failingStreamId - The id of the stream whose setup just failed, excluded from the isolation check.
- * @param inputs.hasBrowser - Whether a browser instance is currently published to probe.
- * @param inputs.reverificationInProgress - Whether a re-verification is already deciding the browser's fate.
- * @returns True when the failure should trigger a re-verification probe.
+ * What one mid-life capture probe established about the browser. A `captured` outcome is the browser proving it can still start a capture; `failed` is the verdict
+ * the mark rests on; `inconclusive` is the probe never having run, which is evidence of neither.
  */
-export declare function shouldReverifyCapture(inputs: {
-    activeStreamIds: readonly number[];
-    failingStreamId: number;
-    hasBrowser: boolean;
-    reverificationInProgress: boolean;
-}): boolean;
-//# sourceMappingURL=setup.d.ts.map
+export type CaptureProbeOutcome = {
+    readonly kind: "captured";
+} | {
+    readonly kind: "failed";
+    readonly reason: string;
+} | {
+    readonly kind: "inconclusive";
+    readonly reason: string;
+};
+/**
+ * Classifies a throw from the probe's run on the capture lock into a verdict or the absence of one. A turn-wait timeout means the probe never got to run: with
+ * other streams tuning at the same moment it queued behind their legitimate acquisitions, and a lock that is busy says something about load, not about the browser
+ * - a holder that is genuinely hung marks the browser through its own wedge. Every other value, the outer deadline above all, means the probe held its turn and its
+ * own acquisition did not settle, which is exactly the failure the mark exists for. Pure and total, so the distinction the detector rests on is pinnable without a
+ * browser.
+ * @param error - The value the lock run threw.
+ * @returns The outcome the detector acts on.
+ */
+export declare function classifyCaptureProbeFailure(error: unknown): CaptureProbeOutcome;
+/**
+ * The collaborators the verdict is reached through: the published-browser read, the mark already recorded against it, the mark this verdict may record, and the
+ * probe that decides. Injected as a default parameter in the shape CreatePageWithCaptureDeps uses, so a test drives the one shared slot and the awaited mark
+ * without a capture lock, a browser, or a Chrome behind them.
+ */
+export interface CaptureVerdictDeps {
+    readonly getBrowserInstance: typeof getBrowserInstance;
+    readonly getCaptureImpairment: typeof getCaptureImpairment;
+    readonly noteBrowserCaptureImpaired: typeof noteBrowserCaptureImpaired;
+    readonly probe: (browser: Browser) => Promise<CaptureProbeOutcome>;
+}
+/**
+ * Passive mid-life capture-death detection, called from the stream-setup failure path when the failure carries a capture-infrastructure signature. It re-verifies
+ * the browser's capture capability with a lock-serialized probe and, on a confirmed failure, marks the browser: its running captures continue, new capture starts
+ * are refused at acquire(), and the adapter relaunches it once nothing depends on it. Any refused start is worth a probe - a browser that is demonstrably
+ * capturing for someone else can still be unable to start another - while a browser that already carries a mark needs no second verdict, so the reason on record
+ * is handed back instead.
+ *
+ * The returned promise settles only once everything the verdict set in motion has settled, the relaunch a `failed` outcome triggers included. That is the whole
+ * reason a caller can act on it: a tune that re-acquired the browser the instant the mark landed would meet the retiring instance's drain, where acquire() rejects
+ * rather than joins, while one that waits for this promise meets the fresh browser or a refusal that means what it says. The promise never rejects; the absence of
+ * a verdict is a null rather than a throw.
+ *
+ * It is deliberately not async: every caller in a burst has to hand back the SAME promise object, because what they are waiting on is the browser's one verdict
+ * rather than their own call's. An async wrapper would give each caller a distinct promise that merely adopts it, and the shared identity the single-flight slot
+ * exists to provide would stop being observable at this boundary.
+ * @param deps - The injected collaborators; defaults to the production ones.
+ * @returns The verdict, or null when no browser is published to reach one about.
+ */
+export declare function noteCaptureInfrastructureFailure(deps?: CaptureVerdictDeps): Promise<Nullable<CaptureProbeOutcome>>;