prismcast 1.12.0 → 1.13.0

package/dist/browser/tabSelection.js

@@ -0,0 +1,547 @@
+import { LOG, evaluateWithAbort, formatError, timeoutSignal, waitWithTimeout } from "../utils/index.js";
+import { CONFIG } from "../config/index.js";
+import { TargetType } from "puppeteer-core";
+import { getExtensionPage } from "puppeteer-stream";
+import { systemClock } from "homebridge-plugin-utils";
+// Constants.
+// The failure when the extension cannot name the tab a page is showing in. Both messages carry the phrase "capture extension" on purpose: streaming/recovery.ts
+// classifies a capture-start failure as capture infrastructure by substring, which is what earns a 503 back-off and a re-verification of the browser rather than a
+// 500 the client would not retry.
+export const TAB_NOT_FOUND_MESSAGE = "The capture extension could not find the page's tab.";
+// The failure when Chrome did not honor the selection. Neither a capture start nor a fullscreen request can proceed against a tab that is not the selected one.
+export const TAB_NOT_SELECTED_MESSAGE = "The capture extension did not select the page's tab.";
+// How long an open waits for the tab it asked for to show up as a target. Chrome has already been told to open it, so this bounds an event arriving rather than
+// any work: an open with no target by now is one that produced none.
+const OPEN_TARGET_WAIT_MS = 3000;
+// The ceiling on a whole open turn, its one retry included. It sits under the deadline a capture start already runs under, so a turn that lapses still leaves the
+// caller that is waiting on it time to get a page the plain way.
+const OPEN_TURN_CEILING_MS = 8000;
+// How many times a turn resolves a carrier and opens against it. The second pass is the retry a wrong-window tab and a carrier that closed under the evaluate
+// both earn: each is evidence about the carrier rather than about the open, so resolving again is the only thing worth doing differently.
+const OPEN_ATTEMPTS = 2;
+// The marker every opened tab wears ahead of its pass's own serial. It is written once here because everything that reasons about a marked tab has to agree on
+// it: the open that asks Chrome for the URL, the scan that looks the tab up among the browser's pages, and the reaper that judges a target by its URL alone.
+const OPEN_NONCE_PREFIX = "prismcast-open-";
+// The whole of the URL prefix a marked tab carries. The reaper tests a target's URL against it and reads the pass's nonce out of what follows.
+const OPEN_NONCE_URL_PREFIX = "about:blank#" + OPEN_NONCE_PREFIX;
+// The production collaborators.
+export const defaultTabSelectionDeps = { getExtensionPage };
+/* The tab id each page was identified as, cached for the page's life. A tab id survives navigation, so one identification per page is enough - while the window
+ * that tab sits in can change under us at any time (a user can drag a tab into another window), which is why the window is read fresh at every hold and never
+ * cached beside the id.
+ */
+const tabIds = new WeakMap();
+// The counter behind each identification's title token. It only moves forward, so no two identifications in this process can match one another's marker.
+let nextTitleToken = 0;
+// The counter behind each open's nonce. It only moves forward for the same reason the title token's does: two opens must never be able to wait for one another's
+// tab, and the nonce is the whole of what tells them apart.
+let nextOpenNonce = 0;
+/* The nonces of the passes still waiting for the tab they asked for. A pass enters its own just before it asks Chrome to open and leaves the moment it claims
+ * a target or gives the pass up, so a marked tab whose nonce is in here is somebody's and one whose nonce is not belongs to nobody - which is the whole of the
+ * test the reaper applies.
+ */
+const waitingOpens = new Set();
+/* The pages passes have claimed. A claimed page keeps its marked URL until its caller navigates it, so the URL alone would read as residue for as long as it
+ * sits there, which is why the reaper consults this before it closes anything. A tab that landed in the wrong window is claimed too and closed by the turn
+ * itself, so nothing here ever needs taking out again.
+ */
+const claimedOpens = new WeakSet();
+// The tail of the selection chain. Each hold is queued onto it and replaces it with its own release signal, so the next hold begins when the selection was handed
+// back rather than when the caller before it finished reading its result.
+let selectionQueue = Promise.resolve();
+// The subscribers the activation report walks. Module-level rather than per-hold, because the fact reported is about the browser's tabs rather than about any one
+// hold, and the capture layer subscribes once for the life of the process.
+const activationListeners = new Set();
+// Activation reporting.
+/**
+ * Subscribes to the activation report: every tab this module activates through the extension, announced by id as soon as the update resolves.
+ *
+ * A captured page cannot hear its own activation, so the module performing the activation is the one place the fact exists to be announced at all. The report
+ * carries the id and stops there, which is what keeps this module's vocabulary to tabs and windows no matter what a subscriber goes on to do with one.
+ * @param listener - Called with the id of each tab this module activates.
+ * @returns The closure that ends the subscription. A subscriber that has gone away without calling it stays in the set for the life of the process.
+ */
+export function onTabActivation(listener) {
+    activationListeners.add(listener);
+    return () => {
+        activationListeners.delete(listener);
+    };
+}
+/**
+ * Announces an activation to every subscriber.
+ *
+ * Each listener is called inside a swallow of its own, because a subscriber is somebody else's code and a hold's correctness cannot rest on it: a throw would
+ * otherwise fail the selection step a capture start is waiting on, or replace the give-back's own reading of what went wrong with a subscriber's.
+ * @param tabId - The tab that was activated.
+ */
+function reportActivation(tabId) {
+    for (const listener of activationListeners) {
+        try {
+            listener(tabId);
+        }
+        catch (error) {
+            LOG.debug("browser:lifecycle", "A tab-activation subscriber failed to handle the report: %s.", formatError(error));
+        }
+    }
+}
+/**
+ * The tab id a page was identified as, when it has one.
+ *
+ * The report names a tab and a subscriber holds pages, so this is the bridge between them. The answer is only ever an id a completed identification cached, which
+ * means a page this module has never selected reads undefined - the right answer for it, because no activation of ours can have named it.
+ * @param page - The page to look up.
+ * @returns The cached tab id, or undefined when this page has not been identified.
+ */
+export function getCachedTabId(page) {
+    return tabIds.get(page);
+}
+// Selection.
+/**
+ * Reads a tab's current state from the extension.
+ * @param extension - The extension's options page.
+ * @param tabId - The tab to read.
+ * @returns The tab as the extension reports it.
+ */
+async function readTab(extension, tabId) {
+    return extension.evaluate((id) => chrome.tabs.get(id), tabId);
+}
+/**
+ * Names the tab a page is showing in, caching the answer for the page's life.
+ *
+ * The extension cannot see CDP target ids, and a capture page is a fresh about:blank when it is first selected - its capture start precedes its navigation - so
+ * there is nothing on the page to match against. A unique token written into the page's own title is something both sides can see: the page sets it, the extension
+ * finds the tab wearing it, and the title it replaced goes back in a finally so a navigated page is never left carrying the marker.
+ * @param page - The page to identify.
+ * @param extension - The extension's options page.
+ * @returns The page's tab id.
+ * @throws When no tab wears the token, or the tab that does carries no id.
+ */
+async function identifyTab(page, extension) {
+    const cached = tabIds.get(page);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const token = "prismcast-tab-" + String(++nextTitleToken);
+    const replaced = await page.evaluate((marker) => {
+        const previousTitle = document.title;
+        document.title = marker;
+        return previousTitle;
+    }, token);
+    try {
+        const tabs = await extension.evaluate(() => chrome.tabs.query({}));
+        const match = tabs.find((tab) => tab.title === token);
+        if (match?.id === undefined) {
+            throw new Error(TAB_NOT_FOUND_MESSAGE);
+        }
+        tabIds.set(page, match.id);
+        return match.id;
+    }
+    finally {
+        try {
+            await page.evaluate((title) => { document.title = title; }, replaced);
+        }
+        catch (error) {
+            // Restoring the title is housekeeping, and a page that has gone away mid-identification has taken its title with it. Letting this reach the caller would
+            // replace the identification's own verdict with a note about the cleanup.
+            LOG.debug("browser:lifecycle", "The page's title could not be restored after identifying its tab: %s.", formatError(error));
+        }
+    }
+}
+/**
+ * Hands the selection back to the tab that had it before this module took it.
+ *
+ * Three readings, three answers: the tab this module selected is still the selected one, so the tab that was selected before gets it back; something else is
+ * selected, so whoever moved it since - a user clicking a tab, login mode opening its page - chose more recently and their choice stands; or the tab cannot be
+ * read at all, which means it has gone and nothing of ours is holding the selection either way. Every path a selection is taken on comes back through here, so
+ * the hold and the open give the tab back on identical terms.
+ * @param extension - The extension's options page.
+ * @param selectedId - The tab this module selected.
+ * @param previousId - The tab that was selected before, when the window had one.
+ */
+async function returnSelection(extension, selectedId, previousId) {
+    if ((previousId === undefined) || (previousId === selectedId)) {
+        return;
+    }
+    let stillSelected = true;
+    try {
+        stillSelected = (await readTab(extension, selectedId)).active === true;
+    }
+    catch (error) {
+        LOG.debug("browser:lifecycle", "The capture extension could not re-read the tab before returning the selection: %s.", formatError(error));
+    }
+    if (!stillSelected) {
+        return;
+    }
+    try {
+        await extension.evaluate((target) => chrome.tabs.update(target, { active: true }), previousId);
+        // The tab handed the selection back can be another stream's capture tab, which is the activation the report matters most for. It sits inside the try so an
+        // update that never happened is never announced.
+        reportActivation(previousId);
+    }
+    catch (error) {
+        // The tab that was selected before may have closed while the selection was held, and there is nothing else to return the selection to.
+        LOG.debug("browser:lifecycle", "The capture extension could not return the selection to the tab that had it: %s.", formatError(error));
+    }
+}
+/**
+ * Runs a body with a page's tab selected in its window, and hands back the tab that was selected before it afterwards.
+ *
+ * Holds are serialized: this queues onto the chain, and the hold that follows begins when this one has given the selection back - not when this caller has
+ * finished reading its result, which is what lets a body that outlives its ceiling keep running without holding the selection or the queue.
+ * @param page - The page whose tab the body needs selected.
+ * @param body - The work to run while the tab is selected. It receives the selected tab.
+ * @param context - The ceiling, clock, and collaborators. Defaults to the capture start's own deadline on the system clock with the production collaborators.
+ * @returns Whatever the body resolves with, even when the hold's ceiling lapsed first.
+ * @throws The body's own rejection, or a selection failure of this module's own.
+ */
+export async function withTabSelected(page, body, context = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Standard pattern for signal promises.
+    const released = Promise.withResolvers();
+    /* The chain advances on the release signal rather than on this call's own promise. Those are different moments whenever a body outlives the ceiling: chaining
+     * the queue on the caller's promise would either hold the selection until the body finally settled, or hand the caller a result the body never produced.
+     * hold() settles the release in a finally on every path, including the paths where the selection was never taken, so the chain cannot wedge on a failure.
+     */
+    const run = selectionQueue.then(async () => hold(page, body, context, released));
+    selectionQueue = released.promise;
+    return run;
+}
+/**
+ * Takes the selection, runs the body under it, and gives the previous tab back.
+ * @param page - The page whose tab is selected.
+ * @param body - The work to run while it is selected.
+ * @param context - The ceiling, clock, and collaborators.
+ * @param released - The signal the executor chains the next hold on, settled as soon as the selection has been handed back.
+ * @returns Whatever the body resolves with.
+ */
+async function hold(page, body, context, released) {
+    const { ceilingMs = CONFIG.streaming.navigationTimeout, clock = systemClock, deps = defaultTabSelectionDeps } = context;
+    try {
+        const extension = await deps.getExtensionPage(page.browser());
+        const id = await identifyTab(page, extension);
+        const tab = await readTab(extension, id);
+        // The window is read fresh on every hold, and the fields the selection depends on are narrowed here rather than asserted downstream, so SelectedTab's
+        // required fields are earned by a read that actually carried them.
+        if ((tab.id === undefined) || (tab.windowId === undefined)) {
+            throw new Error(TAB_NOT_FOUND_MESSAGE);
+        }
+        const windowId = tab.windowId;
+        const [previous] = await extension.evaluate((target) => chrome.tabs.query({ active: true, windowId: target }), windowId);
+        const previousId = previous?.id;
+        // Whether this hold has already reported another window holding the focus. The correction itself runs as often as it is needed - the selection step and every
+        // re-assert perform it - while one report is what an operator needs to see per hold.
+        let focusReported = false;
+        /* Makes this page's window the one Chrome treats as current, and only then. chrome.tabCapture.capture records the active tab of the LAST-FOCUSED window, so a
+         * tab that is merely active in a window Chrome does not consider current is not selected in the sense either caller needs - a site popup holding the focus
+         * would have its own tab recorded instead. This is the one deliberate raise in the module, taken only when the read names a tab in another window.
+         */
+        const focusWindow = async () => {
+            const [focused] = await extension.evaluate(() => chrome.tabs.query({ active: true, lastFocusedWindow: true }));
+            if ((focused?.id === undefined) || (focused.windowId === undefined) || (focused.windowId === windowId)) {
+                return;
+            }
+            if (!focusReported) {
+                focusReported = true;
+                LOG.warn("Another browser window held the focus while a tab was selected for capture, so PrismCast brought its own window forward.", { focusedTab: focused.url ?? null });
+            }
+            await extension.evaluate((target) => chrome.windows.update(target, { focused: true }), windowId);
+        };
+        // Selects this page's tab and confirms Chrome honored it. A selection Chrome did not take is a failure to report rather than one to run a capture start or a
+        // fullscreen request against.
+        const selectTab = async () => {
+            await extension.evaluate((target) => chrome.tabs.update(target, { active: true }), id);
+            // Reported ahead of the confirmation rather than behind it, because the update is what Chrome acted on: a selection that then fails its confirmation was
+            // still an activation, and a heal fired for it is a re-issue against a surface that already carries the right values.
+            reportActivation(id);
+            const confirmed = await readTab(extension, id);
+            if (confirmed.active !== true) {
+                throw new Error(TAB_NOT_SELECTED_MESSAGE);
+            }
+        };
+        try {
+            await selectTab();
+            await focusWindow();
+            const selected = {
+                id,
+                reassert: async () => {
+                    if ((await readTab(extension, id)).active !== true) {
+                        await selectTab();
+                    }
+                    await focusWindow();
+                },
+                url: tab.url ?? null,
+                windowId
+            };
+            /* The ceiling is raced against the body rather than enforced by cancelling it, because the body belongs to the caller and this module has no way to stop it.
+             * The lapse error is this hold's own object, so a lapse is told from the body's own rejection by identity rather than by message.
+             */
+            const lapse = new Error("The tab selection was held longer than " + String(ceilingMs) + " ms.");
+            const running = body(selected);
+            try {
+                return await waitWithTimeout(running, ceilingMs, { clock, reason: lapse });
+            }
+            catch (error) {
+                if (error !== lapse) {
+                    throw error;
+                }
+                LOG.warn("A tab selection was held past its ceiling, so the selection was returned while the operation that took it continues.", { ceilingMs });
+                /* The body keeps running detached and its result still reaches the caller...what ends here is the hold, so the next capture start or fullscreen request
+                 * is not queued behind work this module cannot bound. The promise is returned unawaited on purpose: awaiting it here would put the wait INSIDE the try,
+                 * so the give-back in the finally would sit behind the very body the ceiling just gave up on, and the selection would be held for exactly as long as if
+                 * there were no ceiling at all.
+                 */
+                // eslint-disable-next-line @typescript-eslint/return-await -- Awaiting here would defer the give-back until the body settles, defeating the ceiling.
+                return running;
+            }
+        }
+        finally {
+            await returnSelection(extension, id, previousId);
+        }
+    }
+    finally {
+        released.resolve();
+    }
+}
+// Opening.
+/**
+ * Opens a page as a tab of the shared browser window, and hands the selection straight back to the tab that had it.
+ *
+ * The open belongs here because the open IS a selection change. Chrome picks the window for a plain background page and skips a minimized one, so a capture tab
+ * created while the shared window rests minimized beside a discovery window takes root in the discovery window instead and keeps that window alive long past the
+ * walk it was opened for. The one anchor Chrome honors in every window state is the opener relationship: a window.open evaluated on a page of the shared window
+ * opens its tab in that window, minimized or not, and restores the window on the way in (measured 2026-08-31, both window states).
+ *
+ * Running it as a turn on this module's executor closes two races rather than one. chrome.tabCapture records whichever tab is selected and page creation runs
+ * outside the capture lock, so a bare open could land between a concurrent stream's re-assert and its recording start and put a blank tab on that stream's
+ * recording; and two overlapping opens on one page silently lose all but the first, because a page carries a single transient activation. Serialized turns make
+ * both unrepresentable rather than unlikely.
+ *
+ * Two id spaces meet at this call and are never compared. The window identity a placement is confirmed against belongs to CDP's table, and this module never sees
+ * it - it arrives as an injected answer of true or false. Every id this module reads or writes itself, the tab that was selected and the tab that gets it back,
+ * is the capture extension's.
+ *
+ * Three side effects belong to somebody else. The tab arrives selected, which is why the selection goes back inside this same turn. The open restores a minimized
+ * window, which the window-visibility policy settles afterwards. And the give-back's activation report re-affirms whichever tab regains the selection, so when
+ * that is another stream's capture page its composition wobbles for about a second until the re-affirm ladder lands - the same self-healing wobble a capture
+ * start already causes once, now possible a second time at page creation.
+ * @param browser - The browser to open the tab in.
+ * @param context - The turn's ceiling, the clock it runs on, and the collaborators it runs through.
+ * @returns The opened page, or a page created the plain way when the anchor could not be had.
+ */
+export async function openSharedWindowTab(browser, context) {
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Standard pattern for signal promises.
+    const released = Promise.withResolvers();
+    // The open queues onto the same chain a hold does, and the chain advances on the release signal for the same reason: the next holder begins when this turn has
+    // genuinely finished with the selection.
+    const run = selectionQueue.then(async () => openTurn(browser, context, released));
+    selectionQueue = released.promise;
+    return run;
+}
+/**
+ * Opens the tab under the selection, gives the selection back, and settles - degrading to a plain background page whenever the anchor cannot be had.
+ * @param browser - The browser to open the tab in.
+ * @param context - The turn's ceiling, clock, and collaborators.
+ * @param released - The signal the executor chains the next turn on, settled once this turn has genuinely finished.
+ * @returns The page, opened as a tab of the shared window or created plainly.
+ */
+async function openTurn(browser, context, released) {
+    const { ceilingMs = OPEN_TURN_CEILING_MS, clock = systemClock, deps } = context;
+    const { confirmPlacement, getExtensionPage: lookup = getExtensionPage, resolveCarrier } = deps;
+    /* The fragment the opened tab wears, and the whole of what tells it from any other tab. Chrome reports a fragment on the target verbatim, so the target that
+     * turns up wearing this one is this pass's and nobody else's. Each pass takes a fresh pair, which is what stops a later pass from claiming the tab an earlier
+     * one gave up on, and the scan and the abandon that follow always read whichever pass was the last to run.
+     */
+    let nonce = "";
+    let nonceUrl = "";
+    /* The turn's one ceiling. It is expressed as a signal because that is the form the target wait takes, and it reaches every other await through the bound below.
+     * It CANCELS rather than detaching, which is the opposite of what a hold's ceiling does and deliberately so: a hold's body belongs to its caller and is left to
+     * finish, while a detached open could still land its tab, give the selection back, or close a tab after the queue had already moved on to the next holder -
+     * the alternating-holders race this executor exists to make unrepresentable.
+     */
+    const lapse = new Error("The capture extension's window did not take a new tab within " + String(ceilingMs) + " ms.");
+    const deadline = clock.now() + ceilingMs;
+    const ceiling = timeoutSignal(ceilingMs, { clock, reason: lapse });
+    const bounded = async (work) => waitWithTimeout(work, Math.max(1, deadline - clock.now()), { clock, reason: lapse });
+    // The tab this turn opened, for as long as there is one that might still need closing.
+    let opened = null;
+    /* Closes the tab an abandoned open produced. The target-timeout path holds no page at all, so the tab is looked up among the browser's pages by the marked
+     * URL it still carries: a tab left behind here is one nothing registered, which means the staleness sweep never judges it and it would sit in the window for
+     * the life of the browser.
+     */
+    const closeOpenedTab = async () => {
+        // A turn that failed before its first pass took a marker has nothing to look for, and a page that has yet to navigate reports an empty URL of its own.
+        if (!opened && (nonceUrl === "")) {
+            return;
+        }
+        const tab = opened ?? (await browser.pages()).find((page) => page.url() === nonceUrl) ?? null;
+        opened = null;
+        if (!tab || tab.isClosed()) {
+            return;
+        }
+        try {
+            await tab.close();
+        }
+        catch (error) {
+            LOG.debug("browser:lifecycle", "The tab an abandoned open produced could not be closed: %s.", formatError(error));
+        }
+    };
+    /* Gives the current pass's nonce up and then looks for the tab it opened. The order is what covers the gap between the two: a tab already in the window is what
+     * the scan finds, and one that lands after the scan has looked carries a nonce nobody is waiting for, which is exactly what the reaper closes.
+     */
+    const abandonOpen = async () => {
+        waitingOpens.delete(nonce);
+        await closeOpenedTab();
+    };
+    /* Creates the page the plain way, which is where every degradation ends: no carrier, an open Chrome refused, a spent retry, a lapsed turn, or an extension this
+     * module could not reach at all. That last one is why the fallback exists rather than a throw - extension trouble must not become a new way for an
+     * establishment to fail, because the page still has to exist either way. Giving the guarantee up after the retry was spent is the one case an operator wants to
+     * see, so it is the one case reported above debug.
+     */
+    const fallback = async (reason, retriesSpent) => {
+        if (retriesSpent) {
+            LOG.warn("A capture tab could not be opened in PrismCast's own browser window, so Chrome chose the window for it.", { reason });
+        }
+        else {
+            LOG.debug("browser:lifecycle", "A capture tab was created without the shared window's opener anchor: %s.", reason);
+        }
+        return browser.newPage({ background: true });
+    };
+    try {
+        const extension = await bounded(lookup(browser));
+        /* Why the anchor was given up, when it was given up before both passes were spent. A reason set inside the loop is a degradation with nothing left to try, so
+         * it reports at debug; falling out of the loop with none set means the carrier was resolved twice and the tab still did not land in the shared window, which
+         * is the one abandonment an operator wants to see.
+         */
+        let declined = null;
+        for (let attempt = 1; attempt <= OPEN_ATTEMPTS; attempt++) {
+            // One counter read per pass, spent on both halves of the pair, so the URL Chrome is asked for and the nonce this module reasons in can never disagree.
+            const serial = String(++nextOpenNonce);
+            nonce = OPEN_NONCE_PREFIX + serial;
+            nonceUrl = OPEN_NONCE_URL_PREFIX + serial;
+            // eslint-disable-next-line no-await-in-loop -- Each pass is a fresh resolve and open, and the second only runs because the first told us the carrier was wrong.
+            const carrier = await bounded(resolveCarrier(browser));
+            if (!carrier) {
+                declined = "no page of the shared window was available to open from";
+                break;
+            }
+            let previousId;
+            try {
+                /* The window's own selected tab, read exactly the way a hold reads it: the carrier names its tab, the tab names its window, and the window names the tab
+                 * that will want the selection back. Every id in this block is the capture extension's, which is the only table this module is ever allowed to reason in.
+                 */
+                // eslint-disable-next-line no-await-in-loop -- The carrier read belongs to the pass that resolved it.
+                const carrierTab = await bounded(readTab(extension, await bounded(identifyTab(carrier, extension))));
+                if (carrierTab.windowId === undefined) {
+                    throw new Error(TAB_NOT_FOUND_MESSAGE);
+                }
+                // eslint-disable-next-line no-await-in-loop -- The previous selection has to be read before this pass's open, not before the loop.
+                const [previous] = await bounded(extension.evaluate((target) => chrome.tabs.query({ active: true, windowId: target }), carrierTab.windowId));
+                previousId = previous?.id;
+                // The pass is waiting from the moment Chrome is asked until it has a tab of its own, and a tab somebody is waiting for is one the reaper leaves alone.
+                waitingOpens.add(nonce);
+                // A blocked open answers with a null window rather than throwing, so the return value is read rather than assumed. Chrome runs with popup blocking off,
+                // which leaves a null answer as evidence about the carrier's own state.
+                // eslint-disable-next-line no-await-in-loop -- The open is the pass.
+                if (!(await bounded(evaluateWithAbort(carrier, (target) => window.open(target, "_blank") !== null, [nonceUrl])))) {
+                    declined = "the page the open was evaluated on refused it";
+                    break;
+                }
+            }
+            catch (error) {
+                if (error === lapse) {
+                    throw error;
+                }
+                // A carrier can close between the moment it was resolved and the moment the open is evaluated on it, which is the one failure another resolve can answer.
+                LOG.debug("browser:lifecycle", "The page an open was to be evaluated on could not carry it: %s.", formatError(error));
+                /* Chrome can have run the open before the failure reached us, so this pass gives its own marker up and looks for a tab before the next pass opens under
+                 * a new one. A tab already in the window is closed here, and one still on its way is the reaper's.
+                 */
+                // eslint-disable-next-line no-await-in-loop -- The pass that failed clears up before the pass that follows opens.
+                await abandonOpen();
+                continue;
+            }
+            // eslint-disable-next-line no-await-in-loop -- The tab this pass opened is what this pass then confirms.
+            const target = await browser.waitForTarget((candidate) => candidate.url() === nonceUrl, { signal: ceiling.signal, timeout: OPEN_TARGET_WAIT_MS });
+            // eslint-disable-next-line no-await-in-loop -- Same pass, same tab.
+            const page = await bounded(target.page());
+            if (!page) {
+                throw new Error("The capture extension's window produced a tab with no page behind it.");
+            }
+            opened = page;
+            // The pass has its tab: the wait is over, and the page itself is exempt from the reaper for as long as it lives, whatever its URL goes on to say.
+            waitingOpens.delete(nonce);
+            claimedOpens.add(page);
+            // eslint-disable-next-line no-await-in-loop -- The confirmation is what decides whether this pass was the last one.
+            if (!(await bounded(confirmPlacement(page)))) {
+                // eslint-disable-next-line no-await-in-loop -- A tab in the wrong window is closed before the next pass opens another.
+                await closeOpenedTab();
+                continue;
+            }
+            /* The tab arrived selected, so the selection goes back inside this same turn rather than being left for the capture start that follows. Identifying the tab
+             * first is what makes the give-back's three readings exact, and it is work the capture start would otherwise do moments later against this same page.
+             */
+            // eslint-disable-next-line no-await-in-loop -- The give-back closes the pass that took the selection.
+            await bounded(returnSelection(extension, await bounded(identifyTab(page, extension)), previousId));
+            opened = null;
+            return page;
+        }
+        await abandonOpen();
+        return await fallback(declined ?? "the tab did not open in PrismCast's own browser window", declined === null);
+    }
+    catch (error) {
+        await abandonOpen();
+        return await fallback((error === lapse) ? lapse.message : formatError(error), false);
+    }
+    finally {
+        ceiling.cancel();
+        released.resolve();
+    }
+}
+/**
+ * Installs the listener that closes the tabs abandoned opens leave behind, for the life of the browser it is given.
+ *
+ * A turn's evaluate keeps running inside Chrome after the turn's own wait has ended, so a carrier that was merely slow can land its tab long after the turn
+ * scanned for one and created its page the plain way. Nothing registered that tab, so nothing judges it and nothing closes it. The browser's own target events
+ * are what make it findable: a page target whose URL carries the open marker, and whose nonce no pass is waiting for, is one nobody asked for. Both target
+ * events are read because a window.open target is created at about:blank and takes its URL on the change that follows, which leaves the judgment a function of
+ * the target's URL and this module's own state and nothing else.
+ * @param browser - The browser whose targets to watch.
+ */
+export function installStrayOpenTabReaper(browser) {
+    /* The closing itself, entered only for a target the judgment below has already accepted. It resolves the target's page rather than being handed one, because
+     * a target event carries no page and the page behind a target that has just been created may not exist yet.
+     */
+    const reapTab = async (target, nonce) => {
+        try {
+            const page = await target.page();
+            // A page the browser has already dropped, or one a pass claimed and handed to its caller, is not this listener's to close.
+            if (!page || page.isClosed() || claimedOpens.has(page)) {
+                return;
+            }
+            await page.close();
+            LOG.debug("browser:lifecycle", "Closed a stray tab from an abandoned open: %s.", nonce);
+        }
+        catch (error) {
+            // A stray tab the browser has already dropped is not an error - there is nothing left to close and nothing anyone would do about it - so the whole chain
+            // ends here at debug.
+            LOG.debug("browser:lifecycle", "A stray tab from an abandoned open could not be closed: %s.", formatError(error));
+        }
+    };
+    /* The judgment every target event in the browser passes through. It is a synchronous read of the target's own type and URL against this module's state, so
+     * the events that have nothing to do with an open - which is nearly all of them - cost a type check and a prefix test and nothing more.
+     */
+    const onTarget = (target) => {
+        const url = target.url();
+        if ((target.type() !== TargetType.PAGE) || !url.startsWith(OPEN_NONCE_URL_PREFIX)) {
+            return;
+        }
+        const nonce = OPEN_NONCE_PREFIX + url.slice(OPEN_NONCE_URL_PREFIX.length);
+        // A pass is still waiting for this tab, so it is that pass's to claim rather than this listener's to close.
+        if (waitingOpens.has(nonce)) {
+            return;
+        }
+        void reapTab(target, nonce);
+    };
+    browser.on("targetcreated", onTarget);
+    browser.on("targetchanged", onTarget);
+}
+//# sourceMappingURL=tabSelection.js.map

package/dist/browser/tabSelection.js.map

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

package/dist/browser/tuning/cache.d.ts

@@ -58,4 +58,3 @@ export interface ProviderChannelCache<Entry> {
  * @returns A cache instance holding this provider's entries.
  */
 export declare function createProviderChannelCache<Entry>(toDiscovered: (entry: Entry) => DiscoveredChannel): ProviderChannelCache<Entry>;
-//# sourceMappingURL=cache.d.ts.map

package/dist/browser/tuning/comcastPolymer.d.ts

@@ -21,4 +21,3 @@ export interface ComcastPolymerProviderConfig {
  * @returns A fully configured ProviderModule ready for registration in the coordinator.
  */
 export declare function createComcastPolymerProvider(config: ComcastPolymerProviderConfig): ProviderModule;
-//# sourceMappingURL=comcastPolymer.d.ts.map