@mearl/browser-core 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/domInspection.js

@@ -211,9 +211,21 @@ export function inspectElementsInPage(selector, filter, styles, maxResults, inva
         let hit = null;
         try {
             hit = visible ? (documentRef.elementFromPoint?.(x, y) ?? null) : null;
+            const visited = new Set();
+            while (hit?.shadowRoot?.elementFromPoint && !visited.has(hit)) {
+                visited.add(hit);
+                const inner = hit.shadowRoot.elementFromPoint(x, y);
+                if (!inner || inner === hit)
+                    break;
+                hit = inner;
+            }
         }
         catch { }
-        const topmost = !!hit && (hit === element || element.contains?.(hit));
+        let composedHit = hit;
+        while (composedHit && composedHit !== element) {
+            composedHit = composedHit.parentElement || composedHit.getRootNode?.().host;
+        }
+        const topmost = !!hit && (!!composedHit || element.contains?.(hit));
         const target = hit
             ? {
                 selector: selectorFor(hit),

package/dist/extensionServiceProtocol.d.ts

@@ -1,5 +1,6 @@
 import type { BrowserAccessResult, BrowserActionMap, BrowserJsonValue, BrowserProviderListResult, BrowserProviderLaunchForm, ControlSessionInfo, CookieCopyScope, ManagedBrowserInfo, BrowserReleaseParams, BrowserReleaseResult, PageDownloadParams } from './browserActionProtocol.js';
 import { type AgentServiceActionMap } from './agentServiceProtocol.js';
+import type { BrowserEnhancementRequest, BrowserEnhancementResponse } from './browserEnhancement.js';
 import { type ToolboxServiceActionMap, type ToolboxTaskRequest, type ToolboxTaskResponse } from './toolbox.js';
 export declare const EXTENSION_RPC_VERSION = 1;
 export type OperationRequest<M> = {
@@ -171,6 +172,10 @@ export type ExtensionUiServiceRequest<A extends ExtensionUiServiceAction> = Exte
 export type ExtensionUiServiceResponse<A extends ExtensionUiServiceAction, R> = A extends BrowserManagementAction ? BrowserManagementResponse<A, R> : A extends 'toolbox_task' ? R extends ToolboxTaskRequest ? ToolboxTaskResponse<R> : never : ExtensionUiServiceActionMap[A]['response'];
 export declare function isExtensionUiServiceAction(value: unknown): value is ExtensionUiServiceAction;
 export interface HostToExtensionActionMap {
+    __browser_enhancement: {
+        request: BrowserEnhancementRequest;
+        response: BrowserEnhancementResponse;
+    };
     __preset_installation: {
         request: Record<string, unknown>;
         response: unknown;
@@ -206,6 +211,7 @@ export interface HostToExtensionActionMap {
     __control_cleanup: {
         request: BrowserReleaseParams & {
             tabIds: number[];
+            returningToAgent?: boolean;
         };
         response: BrowserReleaseResult;
     };
@@ -249,6 +255,7 @@ export interface HostToExtensionActionMap {
     };
 }
 export declare const HOST_TO_EXTENSION_ACTIONS: {
+    readonly __browser_enhancement: true;
     readonly __preset_installation: true;
     readonly __preset_browser: true;
     readonly __export_cookies: true;

package/dist/extensionServiceProtocol.js

@@ -28,6 +28,7 @@ export function isExtensionUiServiceAction(value) {
         isCloudConnectorAction(value));
 }
 export const HOST_TO_EXTENSION_ACTIONS = {
+    __browser_enhancement: true,
     __preset_installation: true,
     __preset_browser: true,
     __export_cookies: true,
@@ -89,6 +90,13 @@ export function getExtensionServiceTimeout(action, data = {}) {
         return 40000;
     if (action === 'agent_chat_pick_directory')
         return 300000;
+    if (action === 'agent_chat_install_provider')
+        return 420000;
+    if (action === 'agent_chat_login_qoder')
+        return 60000;
+    // Installation can prepare a plugin's runtime after the Skill manager returns.
+    if (action === 'agent_skills_install' || action === 'agent_skills_update')
+        return 600000;
     if (action.startsWith('agent_skills_'))
         return 130000;
     if ([

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export * from './appProfileDefinition.js';
 export * from './types.js';
+export * from './browserEnhancement.js';
+export * from './browserDiscovery.js';
+export * from './providerAppResources.js';
 export * from './eventFilters.js';
 export * from './requestSerializer.js';
 export * from './boundedRequestBuffer.js';
@@ -10,6 +13,7 @@ export * from './domScrolling.js';
 export * from './domInspection.js';
 export * from './domSnapshot.js';
 export * from './deviceEmulation.js';
+export * from './deviceEnvironmentObservation.js';
 export * from './debuggerTarget.js';
 export * from './rootWebViewNavigation.js';
 export type { AppBridgeStyle, AppBridgeSpec, AppBridgeBehavior, BridgeActionMap, AppSchemeRule, AppMiniProgramConfig, AppMiniProgramPaymentRoute, AppMiniProgramMessageAction, AppMiniProgramMessageRule, AppMiniProgramNativeAction, AppMiniProgramNativeRoute, AppImagePickerConfig, AppOverlayConfig, AppNativeBackConfig, AppLayerUrlProxyConfig, AppTitleBarConfig, AppTitleBarHostStyle, AppSafeAreaInsets, AppRootContainerCookie, AppRootContainerConfig, InjectedAppProfileConfig, AppProfileHostCapabilities, } from './app-profile-runtime/types.js';
@@ -21,6 +25,7 @@ export * from './axSnapshot.js';
 export * from './pageObserver.js';
 export * from './navigationTracker.js';
 export * from './pageAct.js';
+export * from './pageDialog.js';
 export * from './backendNodeRefs.js';
 export * from './pageEffectRefs.js';
 export * from './pageWait.js';
@@ -37,6 +42,7 @@ export * from './pluginPages.js';
 export * from './pluginPageRuntime.js';
 export * from './pluginPageHost.js';
 export * from './browserActionProtocol.js';
+export * from './browserCapabilities.js';
 export * from './runActions.js';
 export * from './sendRequestFiles.js';
 export * from './sendRequestHeaders.js';
@@ -57,3 +63,5 @@ export * from './consumeSseResponse.js';
 export { parseQueryString } from './queryString.js';
 export * from './extensionVersion.js';
 export { MEARL_NATIVE_HOST_NAMES, type NativeHostIntegrationMode } from './nativeHostNames.js';
+export * from './dataStructure.js';
+export * from './requestMetadata.js';

package/dist/index.js

@@ -1,5 +1,8 @@
 export * from './appProfileDefinition.js';
 export * from './types.js';
+export * from './browserEnhancement.js';
+export * from './browserDiscovery.js';
+export * from './providerAppResources.js';
 export * from './eventFilters.js';
 export * from './requestSerializer.js';
 export * from './boundedRequestBuffer.js';
@@ -10,6 +13,7 @@ export * from './domScrolling.js';
 export * from './domInspection.js';
 export * from './domSnapshot.js';
 export * from './deviceEmulation.js';
+export * from './deviceEnvironmentObservation.js';
 export * from './debuggerTarget.js';
 export * from './rootWebViewNavigation.js';
 export * from './axTextMatch.js';
@@ -20,6 +24,7 @@ export * from './axSnapshot.js';
 export * from './pageObserver.js';
 export * from './navigationTracker.js';
 export * from './pageAct.js';
+export * from './pageDialog.js';
 export * from './backendNodeRefs.js';
 export * from './pageEffectRefs.js';
 export * from './pageWait.js';
@@ -36,6 +41,7 @@ export * from './pluginPages.js';
 export * from './pluginPageRuntime.js';
 export * from './pluginPageHost.js';
 export * from './browserActionProtocol.js';
+export * from './browserCapabilities.js';
 export * from './runActions.js';
 export * from './sendRequestFiles.js';
 export * from './sendRequestHeaders.js';
@@ -56,3 +62,5 @@ export * from './consumeSseResponse.js';
 export { parseQueryString } from './queryString.js';
 export * from './extensionVersion.js';
 export { MEARL_NATIVE_HOST_NAMES } from './nativeHostNames.js';
+export * from './dataStructure.js';
+export * from './requestMetadata.js';

package/dist/pageAct.d.ts

@@ -61,6 +61,7 @@ export interface PageActNavigationObserver {
     dispose(): void | Promise<void>;
 }
 export interface PageActDependencies {
+    dialogs?: import('./pageDialog.js').PageDialogState;
     startObservation(): Promise<PageObservationCheckpoint>;
     finishObservation(checkpoint: PageObservationCheckpoint, options: PageObservationWaitOptions): Promise<PageActObservation>;
     startNavigationObserver(options: {
@@ -89,6 +90,7 @@ interface PageActUnavailableObservation {
 export type PageActObservation = PageChangeSet | PageNavigationChange | PageActUnavailableObservation;
 export type PageActObservationResponse = (Omit<PageChangeSet, 'url' | 'title'> & Partial<Pick<PageChangeSet, 'url' | 'title'>>) | PageNavigationChange | PageActUnavailableObservation;
 export interface PageActResult {
+    dialog?: import('./pageDialog.js').PageDialogInfo;
     action: {
         name: string;
         success: boolean;

package/dist/pageAct.js

@@ -209,7 +209,21 @@ export async function runPageAct(input, dependencies) {
         throw new Error('actionData must be an object');
     }
     const typedAction = action;
-    const checkpoint = await dependencies.startObservation();
+    const dialogs = dependencies.dialogs;
+    const guarded = (work) => dialogs ? dialogs.command(work) : work();
+    const dialogResult = (failure, data) => ({
+        action: { name: typedAction, success: !failure, ...(data !== undefined ? { data } : {}), ...failure },
+        ...(dialogs?.info() ? { dialog: dialogs.info() } : {}),
+    });
+    let checkpoint;
+    try {
+        checkpoint = await guarded(() => dependencies.startObservation());
+    }
+    catch (error) {
+        if (!dialogs?.pending)
+            throw error;
+        return dialogResult({ ...describePageActionFailure(error), stage: 'precondition' });
+    }
     const navigationOptions = resolveNavigationWaitOptions(observe);
     const sourceTabId = typeof actionData.tabId === 'number' && Number.isInteger(actionData.tabId)
         ? actionData.tabId
@@ -232,6 +246,14 @@ export async function runPageAct(input, dependencies) {
     catch (error) {
         actionFailure = describePageActionFailure(error);
     }
+    const dispose = () => Promise.allSettled([
+        Promise.resolve().then(() => navigationObserver?.dispose()),
+        Promise.resolve().then(() => dependencies.disposeObservation?.()),
+    ]);
+    if (dialogs?.pending) {
+        await dispose();
+        return dialogResult(actionFailure, actionResult);
+    }
     if (actionFailure?.stage === 'precondition') {
         await Promise.allSettled([
             Promise.resolve().then(() => navigationObserver?.dispose()),
@@ -248,11 +270,15 @@ export async function runPageAct(input, dependencies) {
     }
     let observation;
     try {
-        observation = await dependencies.finishObservation(checkpoint, observe);
+        observation = await guarded(() => dependencies.finishObservation(checkpoint, observe));
     }
     catch (error) {
         observation = unavailableObservation(checkpoint, error);
     }
+    if (dialogs?.pending) {
+        await dispose();
+        return dialogResult(actionFailure, actionResult);
+    }
     const navigationInterruptedAction = isNavigationInterruptedActionFailure(actionFailure);
     if (navigationInterruptedAction && observation.mode === 'navigation') {
         actionFailure = undefined;
@@ -277,22 +303,22 @@ export async function runPageAct(input, dependencies) {
             (navigationObserver.hasStarted() ||
                 shouldWaitForPotentialNavigation(typedAction, observation))) {
             const didNavigate = navigationObserver.hasStarted() ||
-                (await navigationObserver.waitForStart(navigationOptions.graceMs));
+                (await guarded(() => navigationObserver.waitForStart(navigationOptions.graceMs)));
             if (didNavigate) {
-                observation = await navigationObserver.waitForResult(navigationOptions.timeoutMs);
+                observation = await guarded(() => navigationObserver.waitForResult(navigationOptions.timeoutMs));
             }
         }
         if (navigationObserver &&
             (actionFailure === undefined || navigationInterruptedAction) &&
             observation.mode !== 'navigation' &&
             navigationObserver.hasNetworkActivity()) {
-            const network = await navigationObserver.waitForNetworkIdle(navigationOptions.timeoutMs);
+            const network = await guarded(() => navigationObserver.waitForNetworkIdle(navigationOptions.timeoutMs));
             if (navigationObserver.hasStarted()) {
-                observation = await navigationObserver.waitForResult(navigationOptions.timeoutMs);
+                observation = await guarded(() => navigationObserver.waitForResult(navigationOptions.timeoutMs));
             }
             else {
                 try {
-                    observation = await dependencies.finishObservation(checkpoint, observe);
+                    observation = await guarded(() => dependencies.finishObservation(checkpoint, observe));
                 }
                 catch (error) {
                     observation = unavailableObservation(checkpoint, error);
@@ -309,7 +335,7 @@ export async function runPageAct(input, dependencies) {
         }
         if (dependencies.finalizeObservation) {
             try {
-                observation = await dependencies.finalizeObservation(observation);
+                observation = await guarded(() => dependencies.finalizeObservation(observation));
             }
             catch {
                 // Ref enrichment and other response finalizers are best-effort and must
@@ -317,19 +343,25 @@ export async function runPageAct(input, dependencies) {
             }
         }
         if (navigationObserver) {
-            const openedTabs = await navigationObserver
-                .getOpenedTabs(navigationOptions.timeoutMs)
+            const openedTabs = await guarded(() => navigationObserver.getOpenedTabs(navigationOptions.timeoutMs))
                 .catch(() => []);
             if (openedTabs.length > 0)
                 observation = { ...observation, openedTabs };
         }
     }
+    catch (error) {
+        if (!dialogs?.pending)
+            throw error;
+        return dialogResult(actionFailure, actionResult);
+    }
     finally {
         await Promise.allSettled([
             Promise.resolve().then(() => navigationObserver?.dispose()),
             Promise.resolve().then(() => dependencies.disposeObservation?.()),
         ]);
     }
+    if (dialogs?.pending)
+        return dialogResult(actionFailure, actionResult);
     return {
         action: {
             name: typedAction,

package/dist/pageDialog.d.ts

@@ -0,0 +1,66 @@
+export interface PageDialogInfo {
+    id: string;
+    type: 'alert' | 'confirm' | 'prompt' | 'beforeunload';
+    message: string;
+    defaultPrompt?: string;
+    truncated?: true;
+}
+export declare class PageDialogInterruptedError extends Error {
+    readonly pageActionFailureStage: 'precondition' | 'dispatch-uncertain';
+    readonly code = "DIALOG_PENDING";
+    readonly dialog?: PageDialogInfo;
+    readonly details: {
+        dialog?: PageDialogInfo;
+    };
+    constructor(dialog?: PageDialogInfo, pageActionFailureStage?: 'precondition' | 'dispatch-uncertain');
+}
+/** Host-side state only: no page injection, implicit acceptance, or action replay. */
+export declare class PageDialogState {
+    private epoch;
+    private readonly prefix;
+    private current?;
+    private defaultPromptTruncated;
+    private readonly work;
+    private readonly listeners;
+    private handling?;
+    onIdle?: () => void;
+    get pending(): boolean;
+    get busy(): boolean;
+    info(maxChars?: number): PageDialogInfo | undefined;
+    opened(event: {
+        type?: unknown;
+        message?: unknown;
+        defaultPrompt?: unknown;
+    }): void;
+    closed(): void;
+    invalidate(): void;
+    assertCanDispatch(): void;
+    /** Register the actual handler, including its finally; never retain a raw browser Promise here. */
+    execute<T>(work: () => Promise<T>, interrupt?: boolean): Promise<T>;
+    /** Every real eval/input dispatch must pass here, so a late ack cannot resume its handler. */
+    command<T>(work: () => Promise<T>): Promise<T>;
+    private race;
+    press(input: {
+        dialogId?: string;
+        key: string;
+        promptText?: string;
+        selector?: string;
+        modifiers?: unknown[];
+        pressMode?: string;
+    }, send: (params: {
+        accept: boolean;
+        promptText?: string;
+    }) => Promise<unknown>): Promise<{
+        pressed: true;
+        key: string;
+        dispatchMode: 'native-dialog';
+    }>;
+    private notifyIdle;
+}
+export declare function pageDialogSnapshot(dialogs: PageDialogState, mode?: string, maxChars?: number): {
+    snapshot: string;
+    mode: string;
+    elementCount: number;
+    outputNodeCount: number;
+    dialog: PageDialogInfo;
+} | undefined;

package/dist/pageDialog.js

@@ -0,0 +1,175 @@
+import { PageActionDispatchUncertainError } from './pageAct.js';
+export class PageDialogInterruptedError extends Error {
+    pageActionFailureStage;
+    code = 'DIALOG_PENDING';
+    dialog;
+    details;
+    constructor(dialog, pageActionFailureStage = 'dispatch-uncertain') {
+        super(dialog
+            ? `DIALOG_PENDING: native ${dialog.type} dialog ${dialog.id}. Read it with page_snapshot, then use page_press with dialogId and Enter/Escape.`
+            : 'DIALOG_PENDING: a previous page operation was interrupted; observe the page before continuing.');
+        this.pageActionFailureStage = pageActionFailureStage;
+        this.name = 'PageDialogInterruptedError';
+        this.dialog = dialog;
+        this.details = { ...(dialog ? { dialog } : {}) };
+    }
+}
+/** Host-side state only: no page injection, implicit acceptance, or action replay. */
+export class PageDialogState {
+    epoch = 0;
+    prefix = crypto.randomUUID();
+    current;
+    defaultPromptTruncated = false;
+    work = new Set();
+    listeners = new Set();
+    handling;
+    onIdle;
+    get pending() { return this.current !== undefined; }
+    get busy() { return this.work.size > 0 || this.handling !== undefined; }
+    info(maxChars = 240) {
+        if (!this.current)
+            return undefined;
+        const limit = Number.isFinite(maxChars) ? Math.max(0, Math.min(maxChars, 100000)) : 240;
+        const { message, defaultPrompt, ...rest } = this.current;
+        return {
+            ...rest,
+            message: message.slice(0, limit),
+            ...(defaultPrompt ? { defaultPrompt: defaultPrompt.slice(0, limit) } : {}),
+            ...(message.length > limit || (defaultPrompt?.length ?? 0) > limit ? { truncated: true } : {}),
+        };
+    }
+    opened(event) {
+        if (!['alert', 'confirm', 'prompt', 'beforeunload'].includes(String(event.type)))
+            return;
+        this.defaultPromptTruncated = typeof event.defaultPrompt === 'string' && event.defaultPrompt.length > 65536;
+        this.current = {
+            id: `${this.prefix}:${++this.epoch}`,
+            type: event.type,
+            message: typeof event.message === 'string' ? event.message.slice(0, 65536) : '',
+            ...(typeof event.defaultPrompt === 'string' && event.defaultPrompt
+                ? { defaultPrompt: event.defaultPrompt.slice(0, 65536) } : {}),
+            ...((typeof event.message === 'string' && event.message.length > 65536) ||
+                (typeof event.defaultPrompt === 'string' && event.defaultPrompt.length > 65536) ? { truncated: true } : {}),
+        };
+        for (const listener of this.listeners)
+            listener();
+    }
+    closed() {
+        this.current = undefined;
+        this.notifyIdle();
+    }
+    invalidate() {
+        this.epoch += 1;
+        this.current = undefined;
+        for (const listener of this.listeners)
+            listener();
+        this.notifyIdle();
+    }
+    assertCanDispatch() {
+        if (this.pending || [...this.work].some(entry => entry.epoch !== this.epoch)) {
+            throw new PageDialogInterruptedError(this.info(), 'precondition');
+        }
+    }
+    /** Register the actual handler, including its finally; never retain a raw browser Promise here. */
+    execute(work, interrupt = true) {
+        this.assertCanDispatch();
+        const entry = { epoch: this.epoch };
+        this.work.add(entry);
+        let started = false;
+        const release = () => {
+            this.work.delete(entry);
+            this.notifyIdle();
+        };
+        const start = () => {
+            started = true;
+            return Promise.resolve().then(() => {
+                this.assertCanDispatch();
+                return work();
+            }).finally(release);
+        };
+        return (interrupt ? this.race(start) : start()).finally(() => {
+            if (!started)
+                release();
+        });
+    }
+    /** Every real eval/input dispatch must pass here, so a late ack cannot resume its handler. */
+    command(work) {
+        this.assertCanDispatch();
+        return this.race(work);
+    }
+    race(work) {
+        if (this.pending)
+            return Promise.reject(new PageDialogInterruptedError(this.info()));
+        const epoch = this.epoch;
+        return new Promise((resolve, reject) => {
+            const changed = () => {
+                if (epoch === this.epoch)
+                    return;
+                this.listeners.delete(changed);
+                reject(new PageDialogInterruptedError(this.info()));
+            };
+            this.listeners.add(changed);
+            let result;
+            try {
+                result = work();
+            }
+            catch (error) {
+                this.listeners.delete(changed);
+                reject(error);
+                return;
+            }
+            Promise.resolve(result).then(value => {
+                this.listeners.delete(changed);
+                resolve(value);
+            }, error => {
+                this.listeners.delete(changed);
+                reject(error);
+            });
+        });
+    }
+    async press(input, send) {
+        const dialog = this.current;
+        if (!input.dialogId || dialog?.id !== input.dialogId)
+            throw new Error('page_press: dialogId is stale or no native dialog is open. Run page_snapshot.');
+        if (this.handling)
+            throw new Error('page_press: this native dialog is already being handled.');
+        if (!['Enter', 'Escape'].includes(input.key) || input.selector !== undefined || input.modifiers?.length || (input.pressMode && input.pressMode !== 'auto')) {
+            throw new Error('page_press: dialogId requires Enter/Escape without selector, modifiers, or an explicit pressMode.');
+        }
+        if (input.promptText !== undefined && (typeof input.promptText !== 'string' || dialog.type !== 'prompt' || input.key !== 'Enter')) {
+            throw new Error('page_press: promptText is only valid when accepting a native prompt.');
+        }
+        const acceptsPrompt = dialog.type === 'prompt' && input.key === 'Enter';
+        if (acceptsPrompt && input.promptText === undefined && this.defaultPromptTruncated) {
+            throw new Error('page_press: the native prompt default was truncated. Specify promptText explicitly.');
+        }
+        this.handling = dialog.id;
+        try {
+            // No await between the last ID check and send. CDP itself has no atomic dialog-ID CAS.
+            await send({ accept: input.key === 'Enter', ...(acceptsPrompt ? { promptText: input.promptText ?? dialog.defaultPrompt ?? '' } : {}) });
+            return { pressed: true, key: input.key, dispatchMode: 'native-dialog' };
+        }
+        catch (error) {
+            throw new PageActionDispatchUncertainError('page_press: native dialog handling was not acknowledged. Read page_snapshot before trying again.', { cause: error });
+        }
+        finally {
+            this.handling = undefined;
+            // Closed/Opening events own current state; an ack for A must not clear a new dialog B.
+            this.notifyIdle();
+        }
+    }
+    notifyIdle() {
+        if (!this.pending && !this.busy)
+            this.onIdle?.();
+    }
+}
+export function pageDialogSnapshot(dialogs, mode = 'full', maxChars = 25000) {
+    const dialog = dialogs.info(maxChars);
+    return dialog ? {
+        snapshot: `[native ${dialog.type} dialog]`,
+        mode,
+        elementCount: 0,
+        outputNodeCount: 0,
+        dialog,
+    } : undefined;
+}

package/dist/pageObserver.js

@@ -28,9 +28,7 @@ export function isPotentialNavigationRequest(resourceType, url = '') {
     const normalizedType = resourceType.toLowerCase();
     if (normalizedType === 'xhr' || normalizedType === 'fetch')
         return true;
-    if (normalizedType !== 'other')
-        return false;
-    return /(?:\/h5\/(?:mtop|mopen)|\/mtop\.|api-proxy)/i.test(url);
+    return false;
 }
 export function resolveNavigationWaitOptions(options = {}) {
     const timeoutMs = Math.min(Math.max(options.navigationTimeoutMs ?? 15000, 1000), 30000);
@@ -171,7 +169,7 @@ export function installPageObserverInPage(maxBatches = 50) {
     const escapeAttribute = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
     const isInternal = (input) => {
         const element = input?.nodeType === Node.ELEMENT_NODE ? input : (input?.parentElement ?? null);
-        return Boolean(element?.closest('[data-mearl-overlay], #__mtop_click_style'));
+        return Boolean(element?.closest('[data-mearl-overlay], #__mearl_click_style'));
     };
     const isVisible = (element) => {
         if (element.closest('[hidden], [aria-hidden="true"]'))
@@ -810,7 +808,20 @@ export function installPageObserverInPage(maxBatches = 50) {
                 const texts = [];
                 let incompleteText = latestTexts.size > textLimit;
                 for (const [element, effect] of latestTexts) {
-                    const current = readPlainText(element);
+                    let current = readPlainText(element);
+                    // Frameworks can replace a just-observed text leaf with an equivalent node.
+                    // Only reuse its stable selector when the replacement is unique and passes
+                    // the same visibility, clipping and text-completeness checks.
+                    if (!element.isConnected) {
+                        try {
+                            const matches = document.querySelectorAll(effect.selector);
+                            if (matches.length === 1)
+                                current = readPlainText(matches[0]);
+                        }
+                        catch {
+                            // Preserve the fallback when the recorded selector cannot be resolved.
+                        }
+                    }
                     if (!current || current.selector !== effect.selector || current.text !== effect.text) {
                         incompleteText = true;
                         continue;

package/dist/pagePressing.d.ts

@@ -31,7 +31,7 @@ export interface PagePressDomTarget {
 export interface PagePressResultData {
     pressed: true;
     key: string;
-    dispatchMode: PagePressDispatchMode;
+    dispatchMode: PagePressDispatchMode | 'native-dialog';
     fallbackReason?: PagePressFallbackReason;
     target?: PagePressDomTarget;
     keydownCanceled?: boolean;

package/dist/pluginPageHost.js

@@ -302,7 +302,7 @@ export class PluginPageRuntimeHost {
                     !isPluginPageInstanceId(instance.instanceId) ||
                     !instance.host?.hostId ||
                     !instance.host.epoch ||
-                    !/^[a-z][a-z0-9-]*$/.test(instance.plugin) ||
+                    !/^[a-z][a-z0-9_-]*$/.test(instance.plugin) ||
                     !data.runtime?.code ||
                     !Array.isArray(data.runtime.matches))
                     throw new Error('Invalid plugin page attachment');
@@ -614,7 +614,7 @@ export class PluginPageRuntimeHost {
             throw new Error('PLUGIN_PAGE_INVALIDATED: Page left its activation URL range');
     }
     async activation(data, preserveManual = false) {
-        if (!/^[a-z][a-z0-9-]*$/.test(data.plugin))
+        if (!/^[a-z][a-z0-9_-]*$/.test(data.plugin))
             throw new Error('Invalid page activation plugin');
         if (data.enabled === undefined)
             return { activation: this.rules.get(data.plugin) ?? null };

package/dist/providerAppResources.d.ts

@@ -0,0 +1,39 @@
+import type { AppProfileOptions } from './appProfileDefinition.js';
+import type { InjectedAppProfileConfig } from './app-profile-runtime/types.js';
+import type { BrowserCapabilityCatalog } from './browserCapabilities.js';
+import type { GetCapabilitiesParams, BrowserDevicePresetName } from './browserActionProtocol.js';
+import type { ProviderEnhancementTarget } from './browserEnhancement.js';
+export declare const PROVIDER_APP_RESOURCE_PROTOCOL_VERSION = 1;
+export declare const MAX_PROVIDER_APP_RESOURCE_MESSAGE_BYTES: number;
+export type ProviderAppResourceRequest = {
+    operation: 'catalog';
+    params?: GetCapabilitiesParams;
+} | {
+    operation: 'resolve';
+    providerTabId: number;
+    profile: string;
+    options?: AppProfileOptions;
+};
+export interface ProviderAppResourceRevision {
+    capabilityRevision: string | null;
+    installationRevision: string | null;
+}
+export interface ResolvedProviderAppResources extends ProviderAppResourceRevision {
+    config: InjectedAppProfileConfig;
+    recommendedPreset: BrowserDevicePresetName;
+    runtime?: {
+        binding: {
+            id: string;
+            sha256: string;
+        };
+        source: string;
+    };
+}
+/** Code is returned only by explicit resolution, never with ordinary capability discovery. */
+export type ProviderAppResourceResponse = (ProviderAppResourceRevision & {
+    catalog: BrowserCapabilityCatalog['apps'];
+}) | (ResolvedProviderAppResources & {
+    target: Extract<ProviderEnhancementTarget, {
+        ready: true;
+    }>;
+});

package/dist/providerAppResources.js

@@ -0,0 +1,2 @@
+export const PROVIDER_APP_RESOURCE_PROTOCOL_VERSION = 1;
+export const MAX_PROVIDER_APP_RESOURCE_MESSAGE_BYTES = 16 * 1024 * 1024;