prismcast 1.12.1 → 1.14.0

package/dist/browser/index.d.ts

@@ -1,18 +1,30 @@
 import type { Browser, LaunchOptions, Page } from "puppeteer-core";
 import type { BrowserPurpose, CaptureImpairment } from "./browserSupervisor.ts";
-import type { Clock, ProcessInfo } from "../utils/index.ts";
+import type { ChangeRejection, ConfigChange } from "../config/reactivity.ts";
+import type { Config, Nullable } from "../types/index.ts";
 import { clearLoginState, isLoginModeActive } from "./login.ts";
 import { getAllStreams } from "../streaming/registry.ts";
 import { getCachedTabId } from "./tabSelection.ts";
-import type { Nullable } from "../types/index.ts";
+import type { Clock } from "homebridge-plugin-utils";
+import type { ProcessInfo } from "../utils/index.ts";
+import type { SystemStatus } from "../streaming/statusEmitter.ts";
 import type { WindowPlacement } from "./cdp.ts";
 type CaptureProbe = (browser: Browser) => Promise<void>;
 /**
  * Injects the capture-readiness probe used as the capability tier of the launch gate. Called once from streaming/setup.ts at module load (which always precedes any
- * launch, since the streaming layer is imported during server startup). Separating the wiring from the call keeps browser/index.ts free of a streaming-layer import.
+ * launch, since the streaming layer is imported during server startup). Separating the wiring from the call keeps browser/index.ts from importing
+ * streaming/setup.ts, which already imports this module, so the dependency stays one-directional.
  * @param probe - The probe to run against a freshly-launched browser; it resolves when the browser can capture and rejects when it cannot.
  */
 export declare function setCaptureProbe(probe: CaptureProbe): void;
+type StreamTerminator = (streamId: number, channelName: string, reason: string) => void;
+/**
+ * Injects the authoritative stream terminator used when browser readiness is lost. Called once from streaming/lifecycle.ts at module load. Separating the wiring
+ * from the call keeps browser/index.ts from importing streaming/lifecycle.ts, which already imports this module, so the dependency stays one-directional.
+ * @param terminator - The function that tears down one stream and all of the resources it owns.
+ */
+export declare function setStreamTerminator(terminator: StreamTerminator): void;
+export type BrowserRestartCause = "impairment" | "maintenance";
 /**
  * Returns true if graceful shutdown is in progress.
  */
@@ -38,7 +50,7 @@ export declare function pickCarrierPage(pages: readonly Page[]): Nullable<Page>;
  * Records which window the shared one is, reading it from a page that sits in it.
  *
  * This is the one way an identity is written. The launch path calls it once the launch-era pages exist, so every browser this process publishes carries the
- * answer before anything asks for a capture tab, and a probe running against a browser of its own calls the same function rather than reaching for the map.
+ * answer before anything asks for a capture tab.
  * @param browser - The browser whose shared window is being recorded.
  * @param page - A page that sits in that window.
  */
@@ -70,6 +82,13 @@ export type { LoginStatus } from "./login.ts";
 export { endLoginMode, getLoginPage, getLoginStatus, setLoginModeEndObserver, startLoginMode } from "./login.ts";
 export { BrowserCaptureImpairedError, BrowserSupersededError, BrowserUnavailableError } from "./browserSupervisor.ts";
 export type { BrowserPurpose, CaptureImpairment } from "./browserSupervisor.ts";
+/**
+ * Thrown when the browser launched but its capture system failed a launch gate: the capture extension never became ready, or the capture probe found no
+ * working capture across its attempts. setupStream answers it as a capture-infrastructure failure by its type, so its message is free to state what happened.
+ */
+export declare class CaptureLaunchError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
 /**
  * Brings the shared browser window into agreement with the visibility policy. This is the one entry point every layer uses - streaming, recovery, login,
  * precaching, and startup all call it and none of them decide window state themselves.
@@ -78,6 +97,25 @@ export type { BrowserPurpose, CaptureImpairment } from "./browserSupervisor.ts";
  * @returns A promise that resolves once a pass that began at or after this call has completed.
  */
 export declare function syncWindowVisibility(page?: Page): Promise<void>;
+/**
+ * The facts a system status is composed from: the browser and capture state, and the process and registry readings taken beside them. One shape, read by
+ * emitCurrentSystemStatus and composed by composeSystemStatus, so the payload is a pure function of stated facts.
+ */
+interface SystemStatusFacts {
+    readonly browser: Nullable<Pick<Browser, "connected">>;
+    readonly captureImpaired: boolean;
+    readonly memory: Pick<NodeJS.MemoryUsage, "heapUsed" | "rss">;
+    readonly pageCount: number;
+    readonly streams: SystemStatus["streams"];
+    readonly uptime: number;
+}
+/**
+ * Composes the system status the SSE bus carries. A browser reads as connected only when one is published and its connection is live, and the memory readings
+ * carry only the figures the status reports.
+ * @param facts - The browser and capture state and the process and registry readings, read at the moment the status is composed.
+ * @returns The system status.
+ */
+export declare function composeSystemStatus(facts: SystemStatusFacts): SystemStatus;
 /**
  * Computes the current system status and emits it to SSE subscribers. Called when browser state changes significantly or when streams are added/removed.
  */
@@ -86,8 +124,8 @@ export declare function emitCurrentSystemStatus(): Promise<void>;
  * Registers a page as managed by PrismCast. This should be called immediately after creating a page via browser.newPage(). Registered pages are tracked for stale
  * page cleanup, while unregistered pages (manually opened, site popups, etc.) are left alone.
  *
- * Each registered page receives a unique ID that persists for the page's lifetime. This ID is used for comparison and staleness tracking, avoiding potential
- * issues with Page object reference identity.
+ * Each registered page receives a unique ID that persists for the page's lifetime, read back through the Page reference by getManagedPageId. The staleness map,
+ * the in-flight set and the stale page cleanup's decision core all work on this stable string key rather than on Page objects.
  * @param page - The Puppeteer Page to register.
  * @param options - Registration options. Set inFlight when an operation owns the page for its duration but nothing the stale page cleanup reads records that
  *   ownership - a stream setup that has not yet written its page into the registry, or a discovery walk whose page belongs to no stream at all - so the cleanup
@@ -104,11 +142,7 @@ export declare function registerManagedPage(page: Page, options?: {
 export declare function unregisterManagedPage(page: Page): void;
 /**
  * Ensures the data directory exists, creating it if necessary. This should be called during application startup before any operations that depend on the data
- * directory (like browser launch or extension preparation).
- *
- * The data directory stores:
- * - Chrome profile data (cookies, local storage, session state)
- * - Extension files (when running as a packaged executable)
+ * directory, browser launch above all, because the directory holds the Chrome profile data (cookies, local storage, session state).
  */
 export declare function ensureDataDirectory(): Promise<void>;
 /**
@@ -126,6 +160,20 @@ export declare function ensureDataDirectory(): Promise<void>;
  * @returns The PIDs to terminate, in process-table order.
  */
 export declare function findChromeProcessesUsingProfile(processes: readonly ProcessInfo[], profileDir: string, ownPid: number, isProcessAlive: (pid: number) => boolean): number[];
+/**
+ * Finds a live Chrome outside this process that holds our profile directory. A Chrome holds the profile when it roots a tree of processes on the profile and the
+ * kill filter's ownership stage spares it, its parent alive and not this process. The test reads the root because Chrome's helpers carry the profile flag with
+ * the Chrome main as their parent, so a helper's parent, the main, is a live process that is not this one, and every helper of this process's own Chrome would
+ * otherwise read as a holder. It reads the ownership stage rather than a liveness test of its own so it stays in step with the kill filter: the sweep never keeps
+ * the files of a Chrome it ends nor removes those of one it spares. A helper whose parent lacks the profile flag reads as a root, so that error keeps the lock files
+ * rather than removing them, and the next sweep with no Chrome alive removes them.
+ * @param processes - The current process table snapshot: the sweep's scan from before its kill loop, or the teardown's scan once its Chrome has exited.
+ * @param profileDir - The Chrome user-data-dir to match against.
+ * @param ownPid - The current process's PID (a Chrome whose parent is us is ours, never a holder).
+ * @param isProcessAlive - Predicate that returns true when the given PID is currently a live process. Injected so tests do not depend on real PIDs.
+ * @returns The PID of the first holder in process-table order, or null when no live Chrome outside this process holds the profile.
+ */
+export declare function findProfileHolder(processes: readonly ProcessInfo[], profileDir: string, ownPid: number, isProcessAlive: (pid: number) => boolean): Nullable<number>;
 /**
  * Ensures a clean slate for browser launch by terminating any stale Chrome processes and removing orphaned profile lock files. Chrome locks its profile
  * directory while running; if a previous instance crashed without releasing the lock, we cannot launch a new browser with the same profile. Discovery is done
@@ -137,13 +185,23 @@ export declare function findChromeProcessesUsingProfile(processes: readonly Proc
  * process exit handler: Chrome may be running normally (e.g., after a capture probe timeout) and an immediate SIGKILL would corrupt its profile databases,
  * poisoning the Docker volume for subsequent container restarts.
  *
- * The ownership filter makes this function safe to call from any context, including a rejected-duplicate startup's exit handler: a duplicate that never
- * spawned Chrome will find nothing matching its ownership criteria and signal nothing.
+ * The ownership filter and the holder test together make this function safe to call from any context, including a rejected-duplicate startup's exit handler: a
+ * duplicate that never spawned Chrome finds nothing matching its ownership criteria, signals nothing, and leaves the profile's lock files to the live Chrome
+ * that holds them.
  *
  * Called at startup before launching the browser and from the process exit handler as a crash recovery fallback. Safe to call when no stale processes or files
  * exist - the discovery and lock-file cleanup are both no-ops in the empty case.
  */
 export declare function killStaleChrome(): void;
+/**
+ * Removes the profile's lock files and the DevTools port file unless a live Chrome outside this process holds the profile. Chrome writes these while running and
+ * removes them on clean shutdown, but an unclean exit (container kill, SIGKILL, crash) leaves them behind. Stale lock files prevent Chrome from acquiring the
+ * profile, and a stale DevToolsActivePort can confuse the Puppeteer connection. This is the one removal of those files, so each caller, the stale-Chrome sweep and
+ * the teardown primitive, reaches them through the holder test, and none removes them from under a live holder.
+ * @param processes - The process table the holder test reads: the sweep's scan from before its kill loop, or the teardown's scan once its Chrome has exited.
+ * @param profileDir - The Chrome user data directory path.
+ */
+export declare function cleanStaleProfileFiles(processes: readonly ProcessInfo[], profileDir: string): void;
 /**
  * Seeds the extension developer-mode preference into the Chrome profile so the capture extension loads. Chrome loads an unpacked extension only when the profile
  * has extension developer mode enabled, and PrismCast's capture extension is loaded unpacked...without the flag the extension never registers and the capture
@@ -201,6 +259,18 @@ export declare function emulateLayoutSurface(page: Page): Promise<{
     height: number;
     width: number;
 }>;
+/**
+ * Re-issues a capture page's own standing device-metrics override. Chrome composes the capture of a selected tab from the window's fitted presentation rather than
+ * from the emulated surface, and re-sending the page's standing override is what moves the composition back to the emulated surface, while a capture already
+ * composing that surface is left exactly as it was. Callable at any time, from anywhere, at any frequency, because the values sent are the ones Puppeteer has
+ * already declared on this page - nothing about the page's emulation changes.
+ *
+ * The re-issue goes through the page's own emulation session, the one Puppeteer keeps on the page's primary target, because the override is only as durable as
+ * the session that holds it and Chrome restores the window's view size when a session that declared one detaches.
+ * @param page - The page to re-affirm. A page carrying no explicitly declared density is left alone.
+ * @throws Whatever the viewport setter rejects with. Each trigger site decides whether that matters to it.
+ */
+export declare function reaffirmCaptureSurface(page: Page): Promise<void>;
 /**
  * Derives the creation bounds for a window that should open exactly where an existing window rests. The four numbers always travel, so the new window lands on
  * the same frame. The state travels only when it is "maximized", because that is the one state Chrome saves alongside the frame and a maximized window mirrored
@@ -219,14 +289,17 @@ export declare function mirrorPlacement(placement: WindowPlacement): {
 /**
  * Opens a page for a channel guide discovery walk in a browser window of its own, and marks it as belonging to that window.
  *
- * A document renders only while it is the active tab of a window that is not minimized, and the shared window rests minimized whenever nothing is capturing and
- * no sign-in holds it on screen, with its selected tab belonging to the user. A guide walk needs its page to render - an observer-driven channel rail fills its
- * tiles from rendering updates, and a virtualized grid re-renders as the walk scrolls it - yet it is never captured, so it has no claim on the shared window's
- * presentation and no business moving the user's selection. Its own window resolves both: the page is the active tab there from the moment it exists.
+ * A document renders only while Chrome presents it: the active tab of a window the desktop is showing, or a page Chrome counts as captured. The shared window
+ * rests minimized whenever nothing is capturing and no sign-in holds it on screen, with its selected tab belonging to the user. A guide walk needs its page to
+ * render - an observer-driven channel rail fills its tiles from rendering updates, a virtualized grid re-renders as the walk scrolls it, and every wait the walk
+ * makes polls on the page's animation frames - yet it is never captured, so it has no claim on the shared window's presentation and no business moving the
+ * user's selection. A window of its own resolves the tab half: the page is that window's active tab from the moment it exists. The window is created in the
+ * background, so Chrome shows it inactive and moves no focus (measured 2026-08-31), and such a window's document is one Chrome does not present on its own: it
+ * reports itself hidden and unfocused and delivers no animation frame beyond a document load's first ones (measured 2026-09-13). Focus emulation resolves the
+ * presentation half, for the page's whole life - Puppeteer's own emulateFocusedPage carries the mechanism, on the page's own session.
  *
- * The window is created in the background, so Chrome shows it inactive and moves no focus (measured 2026-08-31), and at the shared window's own placement, so
- * the window placement Chrome persists for the profile never changes - readWindowPlacement carries the reasoning. The caller declares the layout surface on
- * the page and owns its registration, and closing the page closes the window with it.
+ * The window opens at the shared window's own placement, so the window placement Chrome persists for the profile never changes - readWindowPlacement carries
+ * the reasoning. The caller declares the layout surface on the page and owns its registration, and closing the page closes the window with it.
  * @param browser - The browser to open the window in.
  * @returns The page, as the active tab of its own window.
  */
@@ -250,7 +323,7 @@ export declare function createDiscoveryPage(browser: Browser): Promise<Page>;
  * @param page - The capture page this callback re-affirms.
  * @param reaffirm - The re-issue to invoke. A parameter rather than a direct call so the callback's behavior can be driven on its own: what it does with the page
  *                   it was built for, what schedule it keeps, and what it does with a rejection, is the whole of its contract.
- * @param clock - The time source the ladder's waits run on. Defaults to realClock.
+ * @param clock - The time source the ladder's waits run on. Defaults to the system clock.
  * @returns The callback, which never rejects. Its promise settles once the ladder is spent, which the page-side listener does not wait on.
  */
 export declare function makeFocusReaffirmCallback(page: Page, reaffirm: (page: Page) => Promise<void>, clock?: Clock): () => Promise<void>;
@@ -294,18 +367,23 @@ export declare function healActivatedCaptureTab(tabId: number, deps?: {
     readonly getCachedTabId: typeof getCachedTabId;
 }): void;
 /**
- * Records that a still-connected browser can no longer start captures - a mid-life capture death that no "disconnected" event would surface - and schedules the
+ * Records that a still-connected browser can no longer start captures - a mid-life capture death that no "disconnected" event would surface - and runs the
  * relaunch that cures it. This is the single recovery action for a browser that is alive and still serving: the mark lives on the supervisor's ready state, so its
  * running captures continue untouched, new stream requests are refused at acquire() with a 503 back-off, the recovery ladder stops offering tab replacement, and
- * the relaunch waits for the registry to empty. Exported for the streaming layer to call once its probe or its wedge has produced the verdict.
+ * the relaunch waits until nothing depends on the browser. Exported for the streaming layer to call once its probe or its wedge has produced the verdict.
+ *
+ * The returned promise settles once the relaunch this mark triggered has settled, which is what a caller that means to use the fresh browser awaits: the teardown
+ * holds the supervisor in its draining state, where acquire() rejects rather than joins, so acquiring any earlier draws that rejection instead of the new
+ * instance. A caller with nothing waiting on the outcome voids it and the relaunch proceeds on its own.
  *
  * The restart trigger uses this function's return value rather than the supervisor's transition observer, deliberately. The observer runs inside transition(), so a
  * restart begun there would call noteReadinessLost re-entrantly while the marking transition's notification is still on the stack. The observer stays a reporter -
  * the alarm and the status emit - and the caller that holds the verdict acts on it once the transition has completed.
  * @param browser - The specific browser instance the caller verified as unable to start captures.
  * @param reason - A short description of the evidence behind the verdict, carried in the alarm log and the impairment record.
+ * @returns A promise settling once the relaunch this mark triggered has settled, or at once when the verdict landed on nothing.
  */
-export declare function noteBrowserCaptureImpaired(browser: Browser, reason: string): void;
+export declare function noteBrowserCaptureImpaired(browser: Browser, reason: string): Promise<void>;
 /**
  * Provides access to the capture-ready browser, launching one if needed. This is the single gated entry point for all browser access: it delegates to the
  * supervisor's acquire(), which returns the ready browser, joins an in-flight launch (single-flight, so concurrent callers never contend on Chrome's profile lock),
@@ -363,43 +441,98 @@ export declare function closeBrowser(): Promise<void>;
  * 2. Exclude pages associated with active streams, and pages an operation still holds in flight
  * 3. Apply a grace period before closing (to handle race conditions)
  * 4. Preserve at least one page to keep the browser alive
+ * @param now - The instant the sweep judges staleness against, read from the interval's own clock so the staleness clocks this sweep starts and the ones it
+ * later reads are stamped on one time source.
  */
-export declare function cleanupStalePages(): Promise<void>;
+export declare function cleanupStalePages(now: number): Promise<void>;
 /**
- * Starts the periodic stale page cleanup interval. This should be called once during server startup, after the browser is initialized. The interval runs
- * indefinitely until stopStalePageCleanup() is called (typically during graceful shutdown).
+ * Starts the periodic stale page cleanup. This should be called once during server startup, after the browser is initialized. The sweep runs indefinitely until
+ * stopStalePageCleanup() is called (typically during graceful shutdown), and a saved interval re-arms it through applyStalePageCleanupChanges(). A second start
+ * while one is running changes nothing.
+ * @param clock - The clock the sweep's interval arms on and whose reading each sweep judges staleness against, so the cadence and the judgment share one time
+ * source. Defaults to the system clock.
  */
-export declare function startStalePageCleanup(): void;
+export declare function startStalePageCleanup(clock?: Clock): void;
 /**
- * Stops the stale page cleanup interval. This should be called during graceful shutdown to prevent the cleanup from running after we've started shutting down
- * the browser and streams.
+ * Stops the periodic stale page cleanup. This should be called during graceful shutdown to prevent the sweep from running after we've started shutting down the
+ * browser and streams. Disposing the registry drains the interval, and a stop with nothing running is a no-op.
  */
 export declare function stopStalePageCleanup(): void;
+/**
+ * Re-arms the running stale-page sweep at a saved cleanup interval. The re-arm restarts the cadence from the save, so the next sweep runs one full interval after
+ * it, and the grace period needs nothing here, because each sweep already reads it when it runs. The handler reads the running sweep and never creates one, so a
+ * save before the boot's start or after the stop arms nothing, and a save can never resurrect a stopped sweep. The interval comes from the candidate, because
+ * the reconcile commits CONFIG only after its handlers run. Re-arming cannot fail, so the handler refuses nothing.
+ * @param _changes - The change to the cleanup interval; the candidate carries the interval, so the handler reads that instead.
+ * @param next - The candidate running configuration.
+ * @returns No rejections.
+ */
+export declare function applyStalePageCleanupChanges(_changes: readonly ConfigChange[], next: Readonly<Config>): Promise<readonly ChangeRejection[]>;
+/**
+ * The registry facts a restart's idleness decision is made from. One shape, read by readRestartFacts and judged by isBrowserIdleForRestart, so the decision stays
+ * a pure function of stated facts rather than of whatever each guard happened to read.
+ */
+interface RestartFacts {
+    readonly establishedStreams: boolean;
+    readonly inFlightPages: number;
+    readonly streamCount: number;
+}
+/**
+ * Decides whether the browser may be torn down for the given cause, from facts read at the call. Each cause asks a different question of the same registry, so
+ * the decision is stated once here rather than spelled out at each guard.
+ *
+ * Maintenance is opportunistic housekeeping, so it waits for an empty registry outright: a pending entry is a tune in progress, and replacing the browser under
+ * one would fail it for nothing better than a fresher instance. Impairment is a repair the tunes themselves are waiting on, so it asks the narrower question of
+ * what a teardown would actually destroy - a stream established on this browser, whose entry holds its page, or a page an operation still holds in flight. A tune
+ * refused a capture start holds neither while it waits for the relaunch, so the very pending entry that maintenance would defer to is not a reason to leave an
+ * unusable browser in place. A tune that has acquired the browser but not yet opened its page falls outside every dependency source for the same reason and
+ * deliberately so: it holds nothing a relaunch would destroy, neither a page nor a capture, and its own capture start would meet the impaired browser in any
+ * case, so the relaunch may run under it.
+ * @param cause - Why the restart wants to run.
+ * @param facts - The registry facts read at the call.
+ * @returns True when the browser may be torn down for this cause.
+ */
+export declare function isBrowserIdleForRestart(cause: BrowserRestartCause, facts: RestartFacts): boolean;
+/**
+ * The facts the maintenance quiet period is decided from. One shape, read by the restart check's tick and judged by decideRestartQuietPeriod, so the decision is
+ * a pure function of stated facts in the way the idleness decision is.
+ */
+interface QuietPeriodFacts {
+    readonly age: number;
+    readonly quietPending: boolean;
+    readonly streamCount: number;
+}
+export type QuietPeriodAction = "arm" | "cancel" | "skip";
+/**
+ * Decides what a restart check's tick does about the maintenance quiet period. A browser younger than BROWSER_MAX_AGE needs no maintenance, so the tick leaves
+ * the countdown as it stands. An old browser with streams registered waits for them: a countdown already running is cancelled, so a stream that starts during
+ * the quiet period resets it, and with no countdown running there is nothing to do. An old browser with an empty registry starts the countdown, unless one is
+ * already running.
+ * @param facts - The browser's age, the registry's size and the countdown's state, read at the tick.
+ * @returns The action the tick takes.
+ */
+export declare function decideRestartQuietPeriod(facts: QuietPeriodFacts): QuietPeriodAction;
 /**
  * Relaunches a browser that can no longer start captures, as soon as nothing depends on it. Every trigger routes here - the mark itself, each stream termination,
  * and the periodic restart check as the backstop for a moment when the other two could not act (login mode above all) - so the decision lives in one place rather
  * than being re-derived by each. Idleness rather than age is the condition, because the mark makes the browser useless for new tunes immediately while its running
- * captures are still worth finishing, so the earliest safe moment is exactly the moment the last of them ends.
+ * captures are still worth finishing, so the earliest safe moment is exactly the moment the last thing depending on this browser lets go of it.
+ *
+ * The returned promise settles once the relaunch has settled, for the caller that goes on to acquire the fresh browser; a trigger with nothing waiting on the
+ * outcome voids it. An early return resolves at once, because there is nothing for such a caller to wait for.
+ * @returns A promise settling once the relaunch has settled, or at once when no relaunch runs.
  */
-export declare function restartBrowserIfImpairedAndIdle(): void;
+export declare function restartBrowserIfImpairedAndIdle(): Promise<void>;
 /**
- * Starts the periodic browser restart eligibility check. This should be called once during server startup, after the browser is initialized. The interval runs
- * indefinitely until stopBrowserRestartChecking() is called (typically during graceful shutdown).
+ * Starts the periodic browser restart eligibility check. This should be called once during server startup, after the browser is initialized. The check runs
+ * indefinitely until stopBrowserRestartChecking() is called (typically during graceful shutdown). A second start while one is running changes nothing.
+ * @param clock - The clock the check's interval and the quiet period it arms both run on, and the browser's age is measured on. Defaults to the system clock.
  */
-export declare function startBrowserRestartChecking(): void;
+export declare function startBrowserRestartChecking(clock?: Clock): void;
 /**
- * Stops the browser restart checking interval and cancels any pending quiet timer. This should be called during graceful shutdown to prevent a restart from
- * racing with server shutdown.
+ * Stops the periodic browser restart eligibility check. This should be called during graceful shutdown to prevent a restart from racing with server shutdown.
+ * Disposing the registry drains the check and any pending quiet period together, and a stop with nothing running is a no-op.
  */
 export declare function stopBrowserRestartChecking(): void;
-/**
- * Extracts the Puppeteer Stream extension files when running as a packaged executable. This copies the extension files from within the packaged binary to the
- * filesystem where Chrome can load them.
- *
- * When running from source (not packaged), this function does nothing - puppeteer-stream can load the extension directly from node_modules.
- * @throws If extension extraction fails.
- */
-export declare function prepareExtension(): Promise<void>;
 export { acquireCaptureStream } from "./tabCapture.ts";
 export type { CaptureStream, CaptureStreamOptions } from "./tabCapture.ts";
-//# sourceMappingURL=index.d.ts.map