teamshare-bridge 0.26.12 → 0.26.14

package/dist/lib/browser/session.js

@@ -55,6 +55,9 @@ const launch_1 = require("./launch");
 const owned_registry_1 = require("./owned-registry");
 const process_1 = require("./process");
 const login_1 = require("./login");
+const page_context_1 = require("./page-context");
+const page_events_1 = require("./page-events");
+const screen_change_1 = require("./screen-change");
 /**
  * Persistent Chrome profile for the AUTO-ANSWER browser (research reads,
  * `browse --auto-answer`, the web-auto-answer tool).
@@ -78,6 +81,12 @@ exports.AUTO_ANSWER_CDP_PORT = 9222;
 exports.DEBUG_CDP_PORT = 9333;
 /** Separate user-data-dir for the debug browser (see DEBUG_CDP_PORT). */
 exports.DEBUG_PROFILE_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), '.teamshare', 'chrome-profile-debug');
+/**
+ * Pages that already carry the debug instrumentation (dialog listener,
+ * frame-navigation re-inject). A WeakSet, because a reconnect creates a new
+ * CdpPage and must instrument it again.
+ */
+const instrumentedPages = new WeakSet();
 class BrowserSession {
     id;
     page = null;
@@ -102,6 +111,13 @@ class BrowserSession {
      * { action: "networkLog" }` when it needs to prove an API mismatch.
      */
     network = new network_log_1.NetworkLog();
+    /**
+     * The native alert/confirm/prompt/beforeunload currently blocking the page
+     * (2026-10). Captured from `Page.javascriptDialogOpening`; other actions are
+     * refused while it is set, and `browser_action({action:"dialog"})` resolves
+     * it. A native dialog blocks the renderer, so a page snapshot would hang.
+     */
+    _nativeDialog = null;
     constructor(id, opts) {
         this.id = id;
         this._port = opts?.port ?? exports.DEBUG_CDP_PORT;
@@ -155,6 +171,10 @@ class BrowserSession {
     get allowCredentials() {
         return this._allowCredentials;
     }
+    /** The native JS dialog currently blocking the page, if any. */
+    get nativeDialog() {
+        return this._nativeDialog;
+    }
     /** Last time a command actually used this session (drives idle close). */
     _lastUsedAt = Date.now();
     /** When this session was last used — the idle-close timer reads this. */
@@ -199,6 +219,7 @@ class BrowserSession {
     async connect(port) {
         if (port)
             this._port = port;
+        this._nativeDialog = null;
         this.touch();
         // Try an existing Chrome first (the human may have started a debug Chrome
         // and signed in on it — reusing it keeps their session and cookies).
@@ -242,6 +263,9 @@ class BrowserSession {
         }
         // Capture the network + console stream for the whole session (QA evidence).
         await this.network.attach(this.page);
+        // Rich page context: persistent toast/dialog buffer, screen-change
+        // observer and native-dialog capture (2026-10).
+        await this.instrumentPage(this.page);
         return (0, cdp_1.getPageInfo)(this.page);
     }
     /**
@@ -265,11 +289,389 @@ class BrowserSession {
             /* best-effort */
         }
         await this.network.attach(this.page);
+        await this.instrumentPage(this.page);
         return (0, cdp_1.getPageInfo)(this.page);
     }
     /**
-     * Navigate to a URL. Returns page info after navigation.
+     * Install the debug browser's page instrumentation (2026-10):
+     *
+     *  - the persistent toast/alert/dialog ring buffer (`page-events.ts`),
+     *    registered for FUTURE documents via
+     *    `Page.addScriptToEvaluateOnNewDocument` and injected into the current
+     *    one immediately;
+     *  - the screen-change observer (`__tsScreenObs.mutated`) so `waitFor
+     *    {for:"change"}` knows a click had an effect without a blind sleep;
+     *  - the native-dialog listener (`Page.javascriptDialogOpening`), because an
+     *    alert/confirm/prompt blocks the renderer and must be surfaced and
+     *    resolved explicitly.
+     *
+     * All pieces are idempotent in the page. The CDP listeners are bound once per
+     * page object (a reconnect creates a new one).
      */
+    async instrumentPage(page) {
+        try {
+            await (0, cdp_1.cdpSend)(page, 'Page.enable', {});
+        }
+        catch {
+            /* already enabled / restricted */
+        }
+        try {
+            await (0, cdp_1.cdpSend)(page, 'Page.addScriptToEvaluateOnNewDocument', {
+                source: (0, page_events_1.buildPageEventScript)(),
+            });
+        }
+        catch {
+            /* older Chrome may refuse; the immediate injection still runs */
+        }
+        const install = async () => {
+            try {
+                await (0, cdp_1.evaluateJs)(page, (0, page_events_1.buildPageEventScript)());
+            }
+            catch {
+                /* document not ready yet; the new-document script covers it */
+            }
+            try {
+                await (0, cdp_1.evaluateJs)(page, (0, screen_change_1.buildObserverScript)());
+            }
+            catch {
+                /* best-effort */
+            }
+        };
+        await install();
+        if (instrumentedPages.has(page))
+            return;
+        instrumentedPages.add(page);
+        (0, cdp_1.onCdpEvent)(page, 'Page.javascriptDialogOpening', (params) => {
+            this._nativeDialog = {
+                type: String(params?.type ?? 'dialog'),
+                message: String(params?.message ?? ''),
+                ...(typeof params?.defaultPrompt === 'string'
+                    ? { defaultPrompt: params.defaultPrompt }
+                    : {}),
+                at: Date.now(),
+            };
+        });
+        (0, cdp_1.onCdpEvent)(page, 'Page.javascriptDialogClosed', () => {
+            this._nativeDialog = null;
+        });
+        // `Page.addScript...` already covers a real navigation; this is the belt
+        // and braces path for a document that was already loading when we attached.
+        (0, cdp_1.onCdpEvent)(page, 'Page.frameNavigated', (params) => {
+            if (!(0, screen_change_1.isMainFrameNavigation)(params))
+                return;
+            setTimeout(() => {
+                void install();
+            }, 600);
+        });
+    }
+    /**
+     * Resolve a native JS dialog (alert/confirm/prompt/beforeunload).
+     * `accept:false` dismisses it; `promptText` is used by a prompt.
+     */
+    async dialogAction(opts) {
+        this.ensureConnected();
+        const current = this._nativeDialog;
+        if (!current) {
+            return { ok: false, error: 'No native browser dialog is open.' };
+        }
+        try {
+            await (0, cdp_1.cdpSend)(this.page, 'Page.handleJavaScriptDialog', {
+                accept: opts.accept !== false,
+                ...(typeof opts.promptText === 'string'
+                    ? { promptText: opts.promptText }
+                    : {}),
+            });
+            this._nativeDialog = null;
+            return {
+                ok: true,
+                accepted: opts.accept !== false,
+                type: current.type,
+                message: current.message,
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Current pagination state (controls, page, page size, total, rows).
+     * Scoped to the top dialog by the page-state script.
+     */
+    async pagination() {
+        this.ensureConnected();
+        const state = await (0, page_context_1.readPageState)(this.page, { includeText: false });
+        return state.pagination;
+    }
+    /** Stable-ish signature used to prove a page actually changed. */
+    async paginationSignature() {
+        const state = await (0, page_context_1.readPageState)(this.page, { includeText: false });
+        let firstRow = '';
+        try {
+            firstRow = String(await (0, cdp_1.evaluateJs)(this.page, `(() => {
+            const vis = (el) => { if (!el) return false; const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0; };
+            const rows = [...document.querySelectorAll('tbody tr,[role="row"]')].filter(vis);
+            const row = rows.find((r) => r.querySelectorAll('td').length > 0);
+            return row ? String(row.innerText || row.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 80) : '';
+          })()`));
+        }
+        catch {
+            /* navigation / context loss */
+        }
+        const p = state.pagination;
+        return [
+            p.page ?? '',
+            p.rowCount,
+            p.total ?? '',
+            firstRow,
+            p.controls.map((c) => `${c.kind}:${c.disabled ? 1 : 0}`).join(','),
+        ].join('|');
+    }
+    async waitPaginationChange(before, timeoutMs = 8000) {
+        const started = Date.now();
+        const deadline = started + Math.min(Math.max(timeoutMs, 500), 30_000);
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 220));
+            try {
+                if ((await this.paginationSignature()) !== before) {
+                    return {
+                        moved: true,
+                        state: await this.pagination(),
+                        elapsedMs: Date.now() - started,
+                    };
+                }
+            }
+            catch {
+                /* navigation during the poll - retry */
+            }
+        }
+        return {
+            moved: false,
+            state: await this.pagination().catch(() => ({
+                kind: 'none',
+                hasNext: false,
+                hasPrev: false,
+                rowCount: 0,
+                pageSizeOptions: [],
+                controls: [],
+            })),
+            elapsedMs: Date.now() - started,
+        };
+    }
+    async clickPagination(kind, page) {
+        const state = await this.pagination();
+        const control = state.controls.find((c) => c.kind === kind && (page === undefined || c.page === page)) ??
+            (kind === 'next'
+                ? state.controls.find((c) => c.kind === 'loadMore')
+                : undefined);
+        if (!control || control.disabled)
+            return { clicked: false };
+        await (0, cdp_1.clickAt)(this.page, control.x, control.y);
+        return { clicked: true, control };
+    }
+    /** Move to the next page (or Load more) and wait for the content to change. */
+    async nextPage(timeoutMs = 8000) {
+        this.ensureConnected();
+        const before = await this.paginationSignature();
+        const clicked = await this.clickPagination('next');
+        if (!clicked.clicked) {
+            return {
+                moved: false,
+                elapsedMs: 0,
+                state: await this.pagination(),
+                reason: 'no enabled next/load-more control',
+            };
+        }
+        const result = await this.waitPaginationChange(before, timeoutMs);
+        return {
+            ...result,
+            ...(result.moved ? {} : { reason: 'page did not change' }),
+        };
+    }
+    /** Move to the previous page. */
+    async prevPage(timeoutMs = 8000) {
+        this.ensureConnected();
+        const before = await this.paginationSignature();
+        const clicked = await this.clickPagination('prev');
+        if (!clicked.clicked) {
+            return {
+                moved: false,
+                elapsedMs: 0,
+                state: await this.pagination(),
+                reason: 'no enabled previous control',
+            };
+        }
+        const result = await this.waitPaginationChange(before, timeoutMs);
+        return {
+            ...result,
+            ...(result.moved ? {} : { reason: 'page did not change' }),
+        };
+    }
+    /** Go to a numbered page; walks next if the page control is not rendered. */
+    async gotoPage(page, timeoutMs = 8000) {
+        this.ensureConnected();
+        const target = Math.max(1, Math.floor(page));
+        const current = await this.pagination();
+        if (current.page === target) {
+            return {
+                moved: false,
+                elapsedMs: 0,
+                state: current,
+                reason: 'already on page',
+            };
+        }
+        const before = await this.paginationSignature();
+        const direct = await this.clickPagination('page', target);
+        if (direct.clicked) {
+            const result = await this.waitPaginationChange(before, timeoutMs);
+            return {
+                ...result,
+                ...(result.moved ? {} : { reason: 'page did not change' }),
+            };
+        }
+        // Walk forward (bounded) when only prev/next controls exist.
+        for (let i = 0; i < Math.min(target, 100); i += 1) {
+            const next = await this.nextPage(timeoutMs);
+            if (!next.moved)
+                return { ...next, reason: next.reason ?? 'page did not change' };
+            if (next.state.page === target)
+                return next;
+        }
+        return {
+            moved: false,
+            elapsedMs: 0,
+            state: await this.pagination(),
+            reason: 'page control not found and the target was not reached',
+        };
+    }
+    /** Select a native page-size option (custom comboboxes use click + waitFor). */
+    async setPageSize(size) {
+        this.ensureConnected();
+        const before = await this.paginationSignature();
+        const changed = await (0, cdp_1.evaluateJs)(this.page, `(() => {
+        const vis = (el) => { if (!el) return false; const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0; };
+        const target = ${Math.max(1, Math.floor(size))};
+        for (const sel of [...document.querySelectorAll('select')].filter(vis)) {
+          const options = [...sel.options];
+          const option = options.find((o) => Number(String(o.textContent || o.label || '').trim()) === target);
+          if (!option) continue;
+          const proto = HTMLSelectElement.prototype;
+          const desc = Object.getOwnPropertyDescriptor(proto, 'value');
+          if (desc && desc.set) desc.set.call(sel, option.value);
+          else sel.value = option.value;
+          sel.dispatchEvent(new Event('input', { bubbles: true }));
+          sel.dispatchEvent(new Event('change', { bubbles: true }));
+          return true;
+        }
+        return false;
+      })()`);
+        if (changed !== true) {
+            return {
+                ok: false,
+                state: await this.pagination(),
+                error: 'page size is not a native select; use getElements + click on the custom combobox',
+            };
+        }
+        const result = await this.waitPaginationChange(before);
+        return {
+            ok: true,
+            state: result.state,
+            ...(result.moved ? {} : { error: 'page did not visibly change' }),
+        };
+    }
+    /**
+     * Read the current table (headers + rows), then walk every page and return
+     * the deduplicated rows. Bounded by maxPages/maxRows; stops on a repeated
+     * page signature, a disabled pager, or an unchanged table.
+     */
+    async collectTable(opts) {
+        this.ensureConnected();
+        if (opts?.pageSize)
+            await this.setPageSize(opts.pageSize);
+        const maxPages = Math.min(Math.max(opts?.maxPages ?? 50, 1), 200);
+        const maxRows = Math.min(Math.max(opts?.maxRows ?? 2000, 1), 10_000);
+        const seen = new Set();
+        const rows = [];
+        let headers = [];
+        let duplicates = 0;
+        let pagesVisited = 0;
+        let stoppedBecause = 'unknown';
+        let truncated = false;
+        const readTable = async () => {
+            try {
+                const raw = await (0, cdp_1.evaluateJs)(this.page, `(() => {
+            const vis = (el) => { if (!el) return false; const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0; };
+            const selector = ${JSON.stringify(opts?.selector ?? '')};
+            let table = selector ? document.querySelector(selector) : null;
+            if (!table) {
+              const tables = [...document.querySelectorAll('table,[role="table"],[role="grid"]')].filter(vis);
+              table = tables.sort((a, b) => b.querySelectorAll('tr,[role="row"]').length - a.querySelectorAll('tr,[role="row"]').length)[0] || null;
+            }
+            if (!table) return null;
+            const headers = [...table.querySelectorAll('thead th,[role="columnheader"]')].map((h) => String(h.innerText || h.textContent || '').replace(/\\s+/g, ' ').trim()).filter(Boolean);
+            const bodyRows = [...table.querySelectorAll('tbody tr,[role="row"]')].filter(vis)
+              .filter((r) => r.querySelectorAll('td,[role="gridcell"],[role="cell"]').length > 0);
+            return {
+              headers,
+              rows: bodyRows.map((r) => [...r.querySelectorAll('td,[role="gridcell"],[role="cell"]')].map((c) => String(c.innerText || c.textContent || '').replace(/\\s+/g, ' ').trim())),
+            };
+          })()`);
+                if (!raw || typeof raw !== 'object')
+                    return null;
+                return raw;
+            }
+            catch {
+                return null;
+            }
+        };
+        for (let page = 0; page < maxPages; page += 1) {
+            const table = await readTable();
+            if (!table) {
+                stoppedBecause = 'no table found';
+                break;
+            }
+            pagesVisited += 1;
+            if (table.headers.length)
+                headers = table.headers;
+            for (const row of table.rows) {
+                const key = row.join('\u0001');
+                if (seen.has(key)) {
+                    duplicates += 1;
+                    continue;
+                }
+                seen.add(key);
+                rows.push(row);
+                if (rows.length >= maxRows) {
+                    truncated = true;
+                    stoppedBecause = 'maxRows';
+                    break;
+                }
+            }
+            if (truncated)
+                break;
+            const next = await this.nextPage();
+            if (!next.moved) {
+                stoppedBecause = next.reason ?? 'end of pages';
+                break;
+            }
+        }
+        const state = await this.pagination().catch(() => null);
+        return {
+            headers,
+            rows,
+            rowCount: rows.length,
+            pagesVisited,
+            ...(state?.total ? { total: state.total } : {}),
+            complete: !truncated &&
+                (stoppedBecause === 'end of pages' ||
+                    stoppedBecause === 'no enabled next/load-more control'),
+            duplicates,
+            truncated,
+            stoppedBecause,
+        };
+    }
     async navigate(url) {
         this.ensureConnected();
         return (0, cdp_1.navigateTo)(this.page, url);
@@ -279,10 +681,7 @@ class BrowserSession {
      */
     async screenshot(format = 'jpeg', quality = 70) {
         this.ensureConnected();
-        const data = await (0, cdp_1.captureScreenshot)(this.page, format, quality);
-        if (!data)
-            throw new Error('Screenshot failed');
-        return data;
+        return (0, cdp_1.captureScreenshotChecked)(this.page, format, quality);
     }
     /**
      * Read the network + console evidence collected for this session (QA).
@@ -308,13 +707,13 @@ class BrowserSession {
      * credential for the run - the debug browser is the QA surface, the
      * auto-answer loop is a separate path that still never touches credentials.
      */
-    async type(text) {
+    async type(text, opts) {
         this.ensureConnected();
         const credential = await (0, login_1.isCredentialFocused)(this.page);
         if (credential && !this._allowCredentials) {
             throw new Error('LOGIN_BLOCKED: refusing to type into a password/credential field. Pass allowCredentials:true on browser_open (debug browser only), use browser_action({action:"login"}) with supplied credentials, or ask the human to sign in.');
         }
-        await (0, login_1.typeTextVerified)(this.page, text);
+        await (0, login_1.typeTextVerified)(this.page, text, opts);
     }
     /**
      * Deterministically fill a login form (username + password) and submit.
@@ -619,6 +1018,195 @@ class BrowserSession {
         this.ensureConnected();
         return (0, cdp_1.getPageInfo)(this.page);
     }
+    /**
+     * Full page state (2026-10): dialogs (topmost with buttons/fields), toasts
+     * (persistent buffer), visible errors, form fields (lengths only), focus,
+     * busy, headings, optional page text, pending requests and console errors.
+     *
+     * This is the debug browser's equivalent of the auto-answer loop's rich
+     * `extractPageContext` - and it is what lets an agent see a login modal
+     * instead of guessing with raw `evaluate`.
+     */
+    async snapshot(opts) {
+        this.ensureConnected();
+        // A native dialog blocks the renderer: an evaluate would hang. Report the
+        // dialog plus the out-of-page evidence instead.
+        if (this._nativeDialog) {
+            return (0, page_context_1.emptyPageSnapshot)(this._nativeDialog, this.network.pendingCount(), this.network.recentErrors(5).map((c) => ({
+                level: c.level,
+                text: c.text,
+                at: c.at,
+            })));
+        }
+        const state = await (0, page_context_1.readPageState)(this.page, opts);
+        return {
+            ...state,
+            nativeDialog: this._nativeDialog,
+            pendingRequests: this.network.pendingCount(),
+            consoleErrors: this.network.recentErrors(5).map((c) => ({
+                level: c.level,
+                text: c.text,
+                at: c.at,
+            })),
+        };
+    }
+    /**
+     * Bounded state attached to every mutating action result. Never include the
+     * page text (that is what `snapshot` is for); a failure returns null so an
+     * action result is never failed by its own observation.
+     */
+    async compactSnapshot() {
+        // A native dialog blocks the renderer; return the dialog + out-of-page
+        // evidence without an evaluate (which would hang).
+        if (this._nativeDialog) {
+            return {
+                url: '',
+                title: '',
+                readyState: 'unknown',
+                modal: false,
+                dialogs: [],
+                fields: [],
+                focused: null,
+                errors: [],
+                toasts: [],
+                busy: false,
+                scroll: { x: 0, y: 0 },
+                nativeDialog: this._nativeDialog,
+                pendingRequests: this.network.pendingCount(),
+                consoleErrors: this.network.recentErrors(3).map((c) => ({
+                    level: c.level,
+                    text: c.text,
+                    at: c.at,
+                })),
+            };
+        }
+        try {
+            const state = await (0, page_context_1.readCompactState)(this.page);
+            if (!state)
+                return null;
+            return {
+                ...state,
+                nativeDialog: this._nativeDialog,
+                pendingRequests: this.network.pendingCount(),
+                consoleErrors: this.network.recentErrors(3).map((c) => ({
+                    level: c.level,
+                    text: c.text,
+                    at: c.at,
+                })),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Recent toast / alert / dialog events from the persistent page buffer.
+     * This is how a toast that disappeared before the next tool call is still
+     * visible.
+     */
+    async events(opts) {
+        this.ensureConnected();
+        if (this._nativeDialog)
+            return { events: [], count: 0 };
+        const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 200);
+        const since = Math.max(0, Number(opts?.since) || 0);
+        let events = [];
+        try {
+            const raw = await (0, cdp_1.evaluateJs)(this.page, `JSON.stringify((window.__tsPageEvents || []).filter((e) => e && e.at >= ${since}).slice(-${limit}))`);
+            const parsed = JSON.parse(String(raw ?? '[]'));
+            if (Array.isArray(parsed))
+                events = parsed;
+        }
+        catch {
+            /* navigation/context loss - return what we have (nothing) */
+        }
+        if (opts?.clear) {
+            try {
+                await (0, cdp_1.evaluateJs)(this.page, '(() => { window.__tsPageEvents = []; return true; })()');
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        return { events, count: events.length };
+    }
+    /**
+     * Wait until a page condition is true, then return the current screen.
+     *
+     * This replaces the manual `evaluate` polling loop the QA agent used to run
+     * (and which broke on "Inspected target navigated"). On timeout it returns
+     * `matched:false` WITH the current screen, so the caller can see why.
+     */
+    async waitFor(opts) {
+        this.ensureConnected();
+        const started = Date.now();
+        const timeout = Math.min(Math.max(Number(opts.timeoutMs) || 10_000, 250), 120_000);
+        const pollMs = Math.min(Math.max(Number(opts.pollMs) || 250, 100), 2_000);
+        const deadline = started + timeout;
+        // Include a toast/mutation that landed just before the wait began.
+        const since = started - 750;
+        const probe = (0, page_context_1.buildWaitProbeScript)({ ...opts, since });
+        let networkIdleTicks = 0;
+        const matched = async () => ({
+            matched: true,
+            elapsedMs: Date.now() - started,
+            for: opts.for,
+            screen: await this.compactSnapshot(),
+            nativeDialog: this._nativeDialog,
+        });
+        while (Date.now() < deadline) {
+            if (this._nativeDialog) {
+                if (opts.for === 'dialog' && opts.state !== 'closed') {
+                    return await matched();
+                }
+                // A native dialog blocks the page: any other condition cannot be
+                // evaluated until the caller resolves it with `dialog`.
+            }
+            else if (opts.for === 'networkIdle') {
+                if (this.network.pendingCount() === 0) {
+                    networkIdleTicks += 1;
+                    if (networkIdleTicks >= 2)
+                        return await matched();
+                }
+                else {
+                    networkIdleTicks = 0;
+                }
+            }
+            else if (opts.for === 'loginStep') {
+                try {
+                    const fields = await (0, login_1.findLoginFields)(this.page);
+                    const phase = (0, login_1.loginStepOf)(fields);
+                    if (!opts.loginPhase || phase === opts.loginPhase) {
+                        return await matched();
+                    }
+                }
+                catch {
+                    /* navigation - retry */
+                }
+            }
+            else {
+                try {
+                    const ok = await (0, cdp_1.evaluateJs)(this.page, probe);
+                    if (ok === true)
+                        return await matched();
+                }
+                catch {
+                    /* "Inspected target navigated" / execution context destroyed: retry */
+                }
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(pollMs, remaining)));
+        }
+        return {
+            matched: false,
+            elapsedMs: Date.now() - started,
+            for: opts.for,
+            screen: await this.compactSnapshot(),
+            nativeDialog: this._nativeDialog,
+        };
+    }
     /**
      * Is the page actually usable right now? (2026-10)
      *
@@ -674,6 +1262,7 @@ class BrowserSession {
             this.page = null;
         }
         this._connected = false;
+        this._nativeDialog = null;
     }
     /**
      * Close the debug browser this session OWNS.