@jackwener/opencli 1.7.14 → 1.7.16

package/dist/src/browser/base-page.js

@@ -9,11 +9,13 @@
  * getCookies, screenshot, tabs, etc.
  */
 import { generateSnapshotJs, getFormStateJs } from './dom-snapshot.js';
+import { buildAxSnapshotFromTrees, findAxRefReplacement } from './ax-snapshot.js';
 import { pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
-import { resolveTargetJs, clickResolvedJs, typeResolvedJs, prepareNativeTypeResolvedJs, verifyFilledResolvedJs, scrollResolvedJs, } from './target-resolver.js';
+import { resolveTargetJs, boundingRectResolvedJs, clickResolvedJs, typeResolvedJs, prepareNativeTypeResolvedJs, verifyFilledResolvedJs, scrollResolvedJs, } from './target-resolver.js';
 import { TargetError } from './target-errors.js';
 import { CliError } from '../errors.js';
 import { formatSnapshot } from '../snapshotFormatter.js';
+import { installVisualRefOverlayJs, removeVisualRefOverlayJs } from './visual-refs.js';
 /**
  * Execute `resolveTargetJs` once, throw structured `TargetError` on failure.
  * Single helper so click/typeText/scrollTo share one resolution pathway,
@@ -62,6 +64,7 @@ export class BasePage {
     /** Cached previous snapshot hashes for incremental diff marking */
     _prevSnapshotHashes = null;
     _cdpTargetMarkerSeq = 0;
+    _axRefs = new Map();
     /**
      * Safely evaluate JS with pre-serialized arguments.
      * Each key in `args` becomes a `const` declaration with JSON-serialized value,
@@ -151,12 +154,35 @@ export class BasePage {
             throw new CliError('FETCH_ERROR', `Expected JSON from ${targetUrl}${contentType}`, previewText(text));
         }
     }
+    async annotatedScreenshot(options = {}) {
+        // Refresh DOM refs first so visual labels map to immediate `browser click <ref>` targets.
+        await this.snapshot({ source: 'dom', viewportExpand: 0 });
+        try {
+            await this.evaluate(installVisualRefOverlayJs());
+            return await this.screenshot({ ...options, annotate: false });
+        }
+        finally {
+            await this.evaluate(removeVisualRefOverlayJs()).catch(() => { });
+        }
+    }
     // ── Shared DOM helper implementations ──
     async click(ref, opts = {}) {
+        const axClick = await this.tryClickAxRef(ref);
+        if (axClick)
+            return axClick;
         // Phase 1: Resolve target with fingerprint verification
         const resolved = await runResolve(this, ref, opts);
         const nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
-        // Phase 2: Execute click on resolved element
+        // Phase 2: measure first so native click can run before DOM el.click().
+        // Custom dropdowns often listen to pointer/mouse down/up; DOM el.click()
+        // only fires click and can silently report success without opening/selecting.
+        const rect = await this.evaluate(boundingRectResolvedJs({ skipScroll: nativeScrolled }));
+        if (rect?.visible === true) {
+            const success = await this.tryNativeClick(rect.x, rect.y);
+            if (success)
+                return resolved;
+        }
+        // JS fallback for older backends or zero-rect targets.
         const result = await this.evaluate(clickResolvedJs({ skipScroll: nativeScrolled }));
         if (typeof result === 'string' || result == null)
             return resolved;
@@ -183,6 +209,115 @@ export class BasePage {
             return false;
         }
     }
+    async tryNativeMouseMove(x, y) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return false;
+        try {
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async tryNativeDoubleClick(x, y) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return false;
+        try {
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 2 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 2 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async tryNativeDrag(from, to) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return false;
+        const midX = Math.round((from.x + to.x) / 2);
+        const midY = Math.round((from.y + to.y) / 2);
+        try {
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x: from.x, y: from.y });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mousePressed', x: from.x, y: from.y, button: 'left', clickCount: 1 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x: midX, y: midY, button: 'left', buttons: 1 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x: to.x, y: to.y, button: 'left', buttons: 1 });
+            await cdp.call(this, 'Input.dispatchMouseEvent', { type: 'mouseReleased', x: to.x, y: to.y, button: 'left', clickCount: 1 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async tryClickAxRef(ref) {
+        if (!/^\d+$/.test(ref))
+            return null;
+        const entry = this._axRefs.get(ref);
+        if (!entry)
+            return null;
+        const nativeClick = this.nativeClick;
+        if (typeof nativeClick !== 'function')
+            return null;
+        const resolved = await this.resolveAxRefPoint(entry);
+        if (!resolved)
+            return null;
+        try {
+            await nativeClick.call(this, resolved.x, resolved.y);
+            return { matches_n: 1, match_level: resolved.matchLevel };
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveAxRefPoint(entry) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return null;
+        if (entry.backendNodeId != null) {
+            const point = await this.axBoxCenter(entry.backendNodeId, entry.frame).catch(() => null);
+            if (point)
+                return { ...point, matchLevel: 'exact' };
+        }
+        await cdp.call(this, 'Accessibility.enable', axEnableParams(entry.frame));
+        const axTree = await cdp.call(this, 'Accessibility.getFullAXTree', axTreeParams(entry.frame)).catch(() => null);
+        const recovered = findAxRefReplacement(axTree, entry);
+        if (!recovered?.backendNodeId)
+            return null;
+        this._axRefs.set(entry.ref, recovered);
+        const point = await this.axBoxCenter(recovered.backendNodeId, recovered.frame).catch(() => null);
+        return point ? { ...point, matchLevel: 'reidentified' } : null;
+    }
+    async axBoxCenter(backendNodeId, frame) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return null;
+        const result = await cdp.call(this, 'DOM.getBoxModel', {
+            backendNodeId,
+            ...(frame?.sessionId
+                ? { frameId: frame.frameId, sessionId: frame.sessionId, ...(frame.targetUrl ? { targetUrl: frame.targetUrl } : {}) }
+                : {}),
+        });
+        const quad = Array.isArray(result?.model?.content) && result.model.content.length >= 8
+            ? result.model.content
+            : Array.isArray(result?.model?.border) && result.model.border.length >= 8
+                ? result.model.border
+                : null;
+        if (!quad)
+            return null;
+        const nums = quad.slice(0, 8).map((value) => typeof value === 'number' ? value : Number(value));
+        if (nums.some((value) => !Number.isFinite(value)))
+            return null;
+        return {
+            x: Math.round((nums[0] + nums[2] + nums[4] + nums[6]) / 4),
+            y: Math.round((nums[1] + nums[3] + nums[5] + nums[7]) / 4),
+        };
+    }
     /** Uses native CDP text insertion when the concrete page exposes it. */
     async tryNativeType(text) {
         const nativeType = this.nativeType;
@@ -219,6 +354,19 @@ export class BasePage {
             return false;
         }
     }
+    async isResolvedFocused() {
+        try {
+            return await this.evaluate(`
+        (() => {
+          const el = window.__resolved;
+          return !!el && (document.activeElement === el || (typeof el.matches === 'function' && el.matches(':focus')));
+        })()
+      `);
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Run a DOM-domain CDP command against `window.__resolved`.
      *
@@ -303,6 +451,322 @@ export class BasePage {
         }
         return resolved;
     }
+    async hover(ref, opts = {}) {
+        const resolved = await runResolve(this, ref, opts);
+        const nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+        const rect = await this.evaluate(boundingRectResolvedJs({ skipScroll: nativeScrolled }));
+        if (rect?.visible === true && await this.tryNativeMouseMove(rect.x, rect.y))
+            return resolved;
+        await this.evaluate(`
+      (() => {
+        const el = window.__resolved;
+        if (!el) throw new Error('No resolved element');
+        if (${nativeScrolled ? 'false' : 'true'}) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        const rect = el.getBoundingClientRect();
+        const init = {
+          bubbles: true,
+          cancelable: true,
+          view: window,
+          clientX: Math.round(rect.left + rect.width / 2),
+          clientY: Math.round(rect.top + rect.height / 2),
+        };
+        try { el.dispatchEvent(new PointerEvent('pointerover', init)); } catch (_) {}
+        try { el.dispatchEvent(new PointerEvent('pointermove', init)); } catch (_) {}
+        el.dispatchEvent(new MouseEvent('mouseover', init));
+        el.dispatchEvent(new MouseEvent('mousemove', init));
+      })()
+    `);
+        return resolved;
+    }
+    async focus(ref, opts = {}) {
+        const resolved = await runResolve(this, ref, opts);
+        let focused = await this.tryCdpOnResolvedElement('DOM.focus') && await this.isResolvedFocused();
+        if (!focused) {
+            focused = await this.evaluate(`
+        (() => {
+          const el = window.__resolved;
+          if (!el || typeof el.focus !== 'function') return false;
+          try { el.focus({ preventScroll: true }); } catch (_) { try { el.focus(); } catch (_) {} }
+          return document.activeElement === el || (typeof el.matches === 'function' && el.matches(':focus'));
+        })()
+      `);
+        }
+        return { ...resolved, focused: !!focused };
+    }
+    async dblClick(ref, opts = {}) {
+        const resolved = await runResolve(this, ref, opts);
+        const nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+        const rect = await this.evaluate(boundingRectResolvedJs({ skipScroll: nativeScrolled }));
+        if (rect?.visible === true && await this.tryNativeDoubleClick(rect.x, rect.y))
+            return resolved;
+        await this.evaluate(`
+      (() => {
+        const el = window.__resolved;
+        if (!el) throw new Error('No resolved element');
+        if (${nativeScrolled ? 'false' : 'true'}) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        const rect = el.getBoundingClientRect();
+        const init = {
+          bubbles: true,
+          cancelable: true,
+          view: window,
+          clientX: Math.round(rect.left + rect.width / 2),
+          clientY: Math.round(rect.top + rect.height / 2),
+          button: 0,
+          detail: 2,
+        };
+        el.dispatchEvent(new MouseEvent('dblclick', init));
+      })()
+    `);
+        return resolved;
+    }
+    async readCheckableState() {
+        return await this.evaluate(`
+      (() => {
+        const el = window.__resolved;
+        if (!el || el.nodeType !== 1) return { ok: false, reason: 'not_checkable' };
+        const tag = el.tagName.toLowerCase();
+        const role = (el.getAttribute('role') || '').toLowerCase();
+        const type = (el.getAttribute('type') || '').toLowerCase();
+        if (tag === 'input' && (type === 'checkbox' || type === 'radio')) {
+          return {
+            ok: true,
+            checked: !!el.checked,
+            disabled: !!el.disabled,
+            kind: type,
+          };
+        }
+        if (role === 'checkbox' || role === 'switch' || role === 'menuitemcheckbox' || role === 'radio' || role === 'menuitemradio') {
+          const aria = (el.getAttribute('aria-checked') || '').toLowerCase();
+          return {
+            ok: true,
+            checked: aria === 'true' || aria === 'mixed',
+            disabled: el.getAttribute('aria-disabled') === 'true' || el.hasAttribute('disabled'),
+            kind: role,
+          };
+        }
+        return { ok: false, reason: 'not_checkable', tag, role };
+      })()
+    `);
+    }
+    async setChecked(ref, checked, opts = {}) {
+        const resolved = await runResolve(this, ref, opts);
+        const before = await this.readCheckableState();
+        if (before?.ok !== true) {
+            throw new TargetError({
+                code: 'not_checkable',
+                message: `Target "${ref}" is not a checkbox, radio, switch, or aria-checked control.`,
+                hint: 'Use `opencli browser state` or `browser find` to pick an input[type=checkbox], input[type=radio], or role=checkbox/switch target.',
+            });
+        }
+        if (before.disabled) {
+            throw new TargetError({
+                code: 'not_checkable',
+                message: `Target "${ref}" is disabled and cannot be ${checked ? 'checked' : 'unchecked'}.`,
+                hint: 'Pick an enabled control, or inspect the form state before retrying.',
+            });
+        }
+        if ((before.kind === 'radio' || before.kind === 'menuitemradio') && !checked) {
+            throw new TargetError({
+                code: 'not_checkable',
+                message: `Target "${ref}" is a radio button and cannot be unchecked directly.`,
+                hint: 'Select another radio option in the same group instead.',
+            });
+        }
+        if (before.checked === checked) {
+            return {
+                ...resolved,
+                checked,
+                changed: false,
+                ...(before.kind ? { kind: before.kind } : {}),
+            };
+        }
+        const clicked = await this.click(ref, opts);
+        const after = await this.readCheckableState();
+        if (after?.ok !== true || after.checked !== checked) {
+            throw new TargetError({
+                code: 'not_checkable',
+                message: `Target "${ref}" did not become ${checked ? 'checked' : 'unchecked'} after click.`,
+                hint: 'The control may be custom, disabled by app logic, or require a different target such as its visible label.',
+            });
+        }
+        return {
+            matches_n: clicked.matches_n,
+            match_level: clicked.match_level,
+            checked,
+            changed: true,
+            ...(after.kind ? { kind: after.kind } : {}),
+        };
+    }
+    async setFileInputBySelector(files, selector) {
+        const setFileInput = this.setFileInput;
+        if (typeof setFileInput === 'function') {
+            await setFileInput.call(this, files, selector);
+            return;
+        }
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function') {
+            throw new Error('File upload requires setFileInput or CDP support from the active browser backend.');
+        }
+        await cdp.call(this, 'DOM.enable', {}).catch(() => undefined);
+        const doc = await cdp.call(this, 'DOM.getDocument', {});
+        const rootNodeId = doc?.root?.nodeId;
+        if (typeof rootNodeId !== 'number')
+            throw new Error('DOM.getDocument returned no root node.');
+        const query = await cdp.call(this, 'DOM.querySelector', { nodeId: rootNodeId, selector });
+        const nodeId = query?.nodeId;
+        if (typeof nodeId !== 'number' || nodeId <= 0)
+            throw new Error(`No element found matching selector: ${selector}`);
+        await cdp.call(this, 'DOM.setFileInputFiles', { files, nodeId });
+    }
+    async uploadFiles(ref, files, opts = {}) {
+        if (!Array.isArray(files) || files.length === 0) {
+            throw new TargetError({
+                code: 'not_file_input',
+                message: 'No files were provided for upload.',
+                hint: 'Pass one or more local file paths after the target.',
+            });
+        }
+        const resolved = await runResolve(this, ref, opts);
+        const markerAttr = 'data-opencli-upload-target';
+        const markerValue = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+        const selector = `[${markerAttr}="${markerValue}"]`;
+        let marked = false;
+        let info = null;
+        try {
+            info = await this.evaluateWithArgs(`
+        (() => {
+          const el = window.__resolved;
+          if (!el || el.nodeType !== 1) return { ok: false, reason: 'not_file_input' };
+          const tag = el.tagName.toLowerCase();
+          const type = (el.getAttribute('type') || '').toLowerCase();
+          if (tag !== 'input' || type !== 'file') return { ok: false, reason: 'not_file_input', tag, type };
+          el.setAttribute(markerAttr, markerValue);
+          return {
+            ok: true,
+            multiple: !!el.multiple,
+            accept: el.getAttribute('accept') || '',
+          };
+        })()
+      `, { markerAttr, markerValue });
+            marked = info?.ok === true;
+            if (!marked) {
+                throw new TargetError({
+                    code: 'not_file_input',
+                    message: `Target "${ref}" is not an input[type=file].`,
+                    hint: 'Use `opencli browser find --css "input[type=file]"` or inspect `compound` output from browser state/find.',
+                });
+            }
+            if (files.length > 1 && !info?.multiple) {
+                throw new TargetError({
+                    code: 'not_file_input',
+                    message: `Target "${ref}" does not allow multiple files, but ${files.length} files were provided.`,
+                    hint: 'Pass one file, or choose a file input with the multiple attribute.',
+                });
+            }
+            await this.setFileInputBySelector(files, selector);
+            const verification = await this.evaluate(`
+        (() => {
+          const el = window.__resolved;
+          const names = [];
+          try {
+            if (el && el.files) {
+              for (let i = 0; i < el.files.length; i++) names.push(el.files[i].name || '');
+            }
+          } catch (_) {}
+          return names;
+        })()
+      `);
+            const fileNames = Array.isArray(verification)
+                ? verification.map((value) => String(value))
+                : [];
+            return {
+                ...resolved,
+                uploaded: true,
+                files: fileNames.length || files.length,
+                file_names: fileNames,
+                target: ref,
+                multiple: !!info?.multiple,
+                ...(info?.accept ? { accept: info.accept } : {}),
+            };
+        }
+        finally {
+            if (marked) {
+                await this.evaluateWithArgs(`
+          (() => {
+            for (const el of document.querySelectorAll(selector)) {
+              el.removeAttribute(markerAttr);
+            }
+          })()
+        `, { selector, markerAttr }).catch(() => undefined);
+            }
+        }
+    }
+    async drag(source, target, opts = {}) {
+        const sourceResolved = await runResolve(this, source, opts.from ?? {});
+        const sourceScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+        const sourceRect = await this.evaluate(`
+      (() => {
+        const el = window.__resolved;
+        if (!el) throw new Error('No resolved drag source');
+        window.__opencli_drag_source = el;
+        if (${sourceScrolled ? 'false' : 'true'}) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        const rect = el.getBoundingClientRect();
+        const w = Math.round(rect.width);
+        const h = Math.round(rect.height);
+        const x = Math.round(rect.left + rect.width / 2);
+        const y = Math.round(rect.top + rect.height / 2);
+        const visible = w > 0 && h > 0 && x >= 0 && y >= 0 && x <= window.innerWidth && y <= window.innerHeight;
+        return { x, y, w, h, visible };
+      })()
+    `);
+        if (sourceRect?.visible !== true) {
+            throw new Error(`Drag source "${source}" has no visible bounding box.`);
+        }
+        try {
+            const targetResolved = await runResolve(this, target, opts.to ?? {});
+            const targetScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+            const endpoints = await this.evaluate(`
+        (() => {
+          const sourceEl = window.__opencli_drag_source;
+          const targetEl = window.__resolved;
+          if (!sourceEl) throw new Error('No resolved drag source');
+          if (!targetEl) throw new Error('No resolved drag target');
+          if (${targetScrolled ? 'false' : 'true'}) targetEl.scrollIntoView({ behavior: 'instant', block: 'center' });
+          const measure = (el) => {
+            const rect = el.getBoundingClientRect();
+            const w = Math.round(rect.width);
+            const h = Math.round(rect.height);
+            const x = Math.round(rect.left + rect.width / 2);
+            const y = Math.round(rect.top + rect.height / 2);
+            const visible = w > 0 && h > 0 && x >= 0 && y >= 0 && x <= window.innerWidth && y <= window.innerHeight;
+            return { x, y, w, h, visible };
+          };
+          return { source: measure(sourceEl), target: measure(targetEl) };
+        })()
+      `);
+            if (endpoints?.source?.visible !== true) {
+                throw new Error(`Drag source "${source}" is not visible at drag time.`);
+            }
+            if (endpoints?.target?.visible !== true) {
+                throw new Error(`Drag target "${target}" has no visible bounding box.`);
+            }
+            const dragged = await this.tryNativeDrag({ x: endpoints.source.x, y: endpoints.source.y }, { x: endpoints.target.x, y: endpoints.target.y });
+            if (!dragged)
+                throw new Error('Native drag requires CDP Input.dispatchMouseEvent support.');
+            return {
+                dragged: true,
+                source,
+                target,
+                source_matches_n: sourceResolved.matches_n,
+                target_matches_n: targetResolved.matches_n,
+                source_match_level: sourceResolved.match_level,
+                target_match_level: targetResolved.match_level,
+            };
+        }
+        finally {
+            await this.evaluate('delete window.__opencli_drag_source').catch(() => { });
+        }
+    }
     async fillText(ref, text, opts = {}) {
         const resolved = await runResolve(this, ref, opts);
         let nativeScrolled = false;
@@ -411,6 +875,20 @@ export class BasePage {
         }
     }
     async snapshot(opts = {}) {
+        if (opts.source === 'ax') {
+            const cdp = this.cdp;
+            if (typeof cdp !== 'function') {
+                throw new CliError('BROWSER_AX_UNAVAILABLE', 'AX snapshot requires CDP support from the active browser backend.', 'Use the default DOM state, or update/reload the Browser Bridge extension.');
+            }
+            const axTrees = await this.collectAxSnapshotTrees(cdp);
+            const built = buildAxSnapshotFromTrees(axTrees, {
+                maxDepth: opts.maxDepth,
+                interactiveOnly: opts.interactive,
+            });
+            this._axRefs = built.refs;
+            return built.text;
+        }
+        this._axRefs.clear();
         const snapshotJs = generateSnapshotJs({
             viewportExpand: opts.viewportExpand ?? 2000,
             maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
@@ -440,6 +918,22 @@ export class BasePage {
             return this._basicSnapshot(opts);
         }
     }
+    async collectAxSnapshotTrees(cdp) {
+        await cdp.call(this, 'Accessibility.enable', {});
+        const rootTree = await cdp.call(this, 'Accessibility.getFullAXTree', {});
+        const trees = [{ tree: rootTree }];
+        const frameTreeResult = await cdp.call(this, 'Page.getFrameTree', {}).catch(() => null);
+        const frames = collectAxFrameRefs(frameTreeResult);
+        for (const frame of frames) {
+            if (frame.sessionId) {
+                await cdp.call(this, 'Accessibility.enable', axEnableParams(frame)).catch(() => null);
+            }
+            const tree = await cdp.call(this, 'Accessibility.getFullAXTree', axTreeParams(frame)).catch(() => null);
+            if (tree)
+                trees.push({ tree, frame });
+        }
+        return trees;
+    }
     async getCurrentUrl() {
         if (this._lastUrl)
             return this._lastUrl;
@@ -509,3 +1003,52 @@ export class BasePage {
         return raw;
     }
 }
+function axTreeParams(frame) {
+    return frame?.frameId
+        ? {
+            frameId: frame.frameId,
+            ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+            ...(frame.targetUrl ? { targetUrl: frame.targetUrl } : {}),
+        }
+        : {};
+}
+function axEnableParams(frame) {
+    return frame?.frameId && frame.sessionId
+        ? { frameId: frame.frameId, sessionId: frame.sessionId, ...(frame.targetUrl ? { targetUrl: frame.targetUrl } : {}) }
+        : {};
+}
+function collectAxFrameRefs(frameTreeResult) {
+    const root = frameTreeResult?.frameTree;
+    const rootUrl = root?.frame?.url || root?.frame?.unreachableUrl || '';
+    const rootOrigin = urlOrigin(rootUrl);
+    if (!root || !rootOrigin)
+        return [];
+    const frames = [];
+    function collect(node) {
+        for (const child of node?.childFrames ?? []) {
+            const frame = child.frame;
+            const frameId = frame?.id;
+            const frameUrl = frame?.url || frame?.unreachableUrl || '';
+            const origin = urlOrigin(frameUrl);
+            if (!frameId)
+                continue;
+            if (origin === rootOrigin) {
+                frames.push({ frameId, url: frameUrl });
+                collect(child);
+            }
+            else {
+                frames.push({ frameId, url: frameUrl, targetUrl: frameUrl, sessionId: 'target' });
+            }
+        }
+    }
+    collect(root);
+    return frames;
+}
+function urlOrigin(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return null;
+    }
+}