npm - @rstest/browser - Versions diffs - 0.8.4 → 0.9.0 - Mend

@rstest/browser 0.8.4 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (79) hide show

package/LICENSE-APACHE-2.0 +202 -0
package/NOTICE +11 -0
package/dist/361.js +8 -0
package/dist/augmentExpect.d.ts +73 -0
package/dist/browser-container/container-static/css/index.5c72297783.css +1 -0
package/dist/browser-container/container-static/js/{392.28f9a733.js → 101.36a8ccdf84.js} +4068 -3904
package/dist/browser-container/container-static/js/101.36a8ccdf84.js.LICENSE.txt +1 -0
package/dist/browser-container/container-static/js/{index.129eaf9c.js → index.0687a8142a.js} +742 -692
package/dist/browser-container/container-static/js/{lib-react.97ee79b0.js → lib-react.dcf2a5e57a.js} +10 -10
package/dist/browser-container/container-static/js/lib-react.dcf2a5e57a.js.LICENSE.txt +1 -0
package/dist/browser-container/index.html +1 -1
package/dist/browser.d.ts +2 -0
package/dist/browser.js +583 -0
package/dist/browserRpcRegistry.d.ts +18 -0
package/dist/client/api.d.ts +3 -0
package/dist/client/browserRpc.d.ts +2 -0
package/dist/client/dispatchTransport.d.ts +11 -0
package/dist/client/entry.d.ts +1 -5
package/dist/client/locator.d.ts +125 -0
package/dist/client/snapshot.d.ts +0 -6
package/dist/concurrency.d.ts +12 -0
package/dist/dispatchCapabilities.d.ts +34 -0
package/dist/dispatchRouter.d.ts +20 -0
package/dist/headlessLatestRerunScheduler.d.ts +19 -0
package/dist/headlessTransport.d.ts +12 -0
package/dist/index.js +1608 -296
package/dist/protocol.d.ts +44 -33
package/dist/providers/index.d.ts +79 -0
package/dist/providers/playwright/compileLocator.d.ts +3 -0
package/dist/providers/playwright/dispatchBrowserRpc.d.ts +13 -0
package/dist/providers/playwright/expectUtils.d.ts +24 -0
package/dist/providers/playwright/implementation.d.ts +2 -0
package/dist/providers/playwright/index.d.ts +1 -0
package/dist/providers/playwright/runtime.d.ts +5 -0
package/dist/providers/playwright/textMatcher.d.ts +8 -0
package/dist/rpcProtocol.d.ts +145 -0
package/dist/runSession.d.ts +33 -0
package/dist/sessionRegistry.d.ts +34 -0
package/dist/sourceMap/sourceMapLoader.d.ts +14 -0
package/dist/watchRerunPlanner.d.ts +21 -0
package/package.json +16 -11
package/src/AGENTS.md +128 -0
package/src/augmentExpect.ts +62 -0
package/src/browser.ts +3 -0
package/src/browserRpcRegistry.ts +57 -0
package/src/client/AGENTS.md +82 -0
package/src/client/api.ts +213 -0
package/src/client/browserRpc.ts +86 -0
package/src/client/dispatchTransport.ts +178 -0
package/src/client/entry.ts +109 -39
package/src/client/locator.ts +452 -0
package/src/client/snapshot.ts +32 -97
package/src/client/sourceMapSupport.ts +26 -37
package/src/concurrency.ts +62 -0
package/src/dispatchCapabilities.ts +162 -0
package/src/dispatchRouter.ts +82 -0
package/src/env.d.ts +8 -1
package/src/headlessLatestRerunScheduler.ts +76 -0
package/src/headlessTransport.ts +28 -0
package/src/hostController.ts +1292 -367
package/src/protocol.ts +66 -31
package/src/providers/index.ts +103 -0
package/src/providers/playwright/compileLocator.ts +130 -0
package/src/providers/playwright/dispatchBrowserRpc.ts +372 -0
package/src/providers/playwright/expectUtils.ts +57 -0
package/src/providers/playwright/implementation.ts +33 -0
package/src/providers/playwright/index.ts +1 -0
package/src/providers/playwright/runtime.ts +32 -0
package/src/providers/playwright/textMatcher.ts +10 -0
package/src/rpcProtocol.ts +220 -0
package/src/runSession.ts +110 -0
package/src/sessionRegistry.ts +89 -0
package/src/sourceMap/sourceMapLoader.ts +96 -0
package/src/watchRerunPlanner.ts +77 -0
package/dist/browser-container/container-static/css/index.5a71c757.css +0 -1
package/dist/browser-container/container-static/js/392.28f9a733.js.LICENSE.txt +0 -1
package/dist/browser-container/container-static/js/lib-react.97ee79b0.js.LICENSE.txt +0 -1
package/dist/browser-container/container-static/js/scheduler.6976de44.js +0 -411
package/dist/browser-container/scheduler.html +0 -19

package/dist/browser-container/container-static/js/{lib-react.97ee79b0.js → lib-react.dcf2a5e57a.js} RENAMED Viewed

@@ -1,12 +1,12 @@
-/*! For license information please see lib-react.97ee79b0.js.LICENSE.txt */
-/*! For license information please see lib-react.97ee79b0.js.LICENSE.txt */ "use strict";
-(self.webpackChunk_rstest_browser_ui = self.webpackChunk_rstest_browser_ui || []).push([
+/*! For license information please see lib-react.dcf2a5e57a.js.LICENSE.txt */
+/*! LICENSE: lib-react.dcf2a5e57a.js.LICENSE.txt */ "use strict";
+(self.rspackChunk_rstest_browser_ui = self.rspackChunk_rstest_browser_ui || []).push([
     [
         "783"
     ],
     {
         7816 (e, t, n) {
-            var r, l = n(1099), a = n(162), o = n(5466);
+            var r, l = n(1099), a = n(162), o = n(3085);
             function i(e) {
                 var t = "https://react.dev/errors/" + e;
                 if (1 < arguments.length) {
@@ -1865,19 +1865,19 @@
             }
             var r7 = D.S;
             D.S = function(e, t) {
-                i3 = el(), "object" == typeof t && null !== t && "function" == typeof t.then && function(e, t) {
+                i3 = el(), "object" == typeof t && null !== t && "function" == typeof t.then && function(e) {
                     if (null === r4) {
-                        var n = r4 = [];
+                        var t = r4 = [];
                         r8 = 0, r6 = uJ(), r5 = {
                             status: "pending",
                             value: void 0,
                             then: function(e) {
-                                n.push(e);
+                                t.push(e);
                             }
                         };
                     }
-                    r8++, t.then(r9, r9);
-                }(0, t), null !== r7 && r7(e, t);
+                    r8++, e.then(r9, r9);
+                }(t), null !== r7 && r7(e, t);
             };
             var le = I(null);
             function lt() {
@@ -7947,7 +7947,7 @@
                 }
             })(), e.exports = n(7816);
         },
-        5466 (e, t, n) {
+        3085 (e, t, n) {
             (function e() {
                 if ("u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE) try {
                     __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e);

package/dist/browser-container/container-static/js/lib-react.dcf2a5e57a.js.LICENSE.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ /! LICENSE: lib-react.dcf2a5e57a.js.LICENSE.txt /

package/dist/browser-container/index.html CHANGED Viewed

@@ -12,7 +12,7 @@
     <script>
       window.__RSTEST_BROWSER_OPTIONS__ = __RSTEST_OPTIONS_PLACEHOLDER__;
     </script>
-  <script defer src="/container-static/js/lib-react.97ee79b0.js"></script><script defer src="/container-static/js/392.28f9a733.js"></script><script defer src="/container-static/js/index.129eaf9c.js"></script><link href="/container-static/css/index.5a71c757.css" rel="stylesheet"></head>
+  <script defer src="/container-static/js/lib-react.dcf2a5e57a.js"></script><script defer src="/container-static/js/101.36a8ccdf84.js"></script><script defer src="/container-static/js/index.0687a8142a.js"></script><link href="/container-static/css/index.5c72297783.css" rel="stylesheet"></head>
   <body>
     <div id="root"></div>
   </body>

package/dist/browser.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import './augmentExpect';
2	+ export * from './client/api';

package/dist/browser.js ADDED Viewed

@@ -0,0 +1,583 @@
+import { DISPATCH_RESPONSE_TYPE, DISPATCH_METHOD_RPC, DISPATCH_RPC_REQUEST_TYPE, DISPATCH_MESSAGE_TYPE, DISPATCH_NAMESPACE_BROWSER } from "./361.js";
+const DEFAULT_RPC_TIMEOUT_MS = 30000;
+const getRpcTimeout = ()=>window.__RSTEST_BROWSER_OPTIONS__?.rpcTimeout ?? DEFAULT_RPC_TIMEOUT_MS;
+const pendingRequests = new Map();
+let requestIdCounter = 0;
+let messageListenerInitialized = false;
+const createRequestId = (prefix)=>{
+    if ('function' == typeof globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+    requestIdCounter += 1;
+    return `${prefix}-${Date.now().toString(36)}-${requestIdCounter.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+const isDispatchResponse = (value)=>'object' == typeof value && null !== value && 'requestId' in value && 'string' == typeof value.requestId;
+const settlePendingRequest = (response)=>{
+    const pending = pendingRequests.get(response.requestId);
+    if (!pending) return;
+    pendingRequests.delete(response.requestId);
+    if (response.stale) return void pending.reject(new Error(pending.staleMessage));
+    if (response.error) return void pending.reject(new Error(response.error));
+    pending.resolve(response.result);
+};
+const initMessageListener = ()=>{
+    if (messageListenerInitialized) return;
+    messageListenerInitialized = true;
+    window.addEventListener('message', (event)=>{
+        if (event.data?.type === DISPATCH_RESPONSE_TYPE) settlePendingRequest(event.data.payload);
+    });
+};
+const unwrapDispatchBridgeResult = (requestId, result, staleMessage)=>{
+    if (!isDispatchResponse(result)) throw new Error('Invalid dispatch bridge response payload.');
+    if (result.requestId !== requestId) throw new Error(`Mismatched dispatch response id: expected ${requestId}, got ${result.requestId}`);
+    if (result.stale) throw new Error(staleMessage);
+    if (result.error) throw new Error(result.error);
+    return result.result;
+};
+const dispatchRpc = ({ requestId, request, timeoutMs, timeoutMessage, staleMessage })=>{
+    if (window.parent === window) {
+        const dispatchBridge = window.__rstest_dispatch_rpc__;
+        if (!dispatchBridge) throw new Error('Dispatch RPC bridge is not available in top-level runner.');
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
+                reject(new Error(timeoutMessage));
+            }, timeoutMs);
+            const call = Promise.resolve(dispatchBridge(request)).then((result)=>unwrapDispatchBridgeResult(requestId, result, staleMessage));
+            call.then((result)=>{
+                clearTimeout(timeoutId);
+                resolve(result);
+            }).catch((error)=>{
+                clearTimeout(timeoutId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
+    initMessageListener();
+    return new Promise((resolve, reject)=>{
+        const timeoutId = setTimeout(()=>{
+            pendingRequests.delete(requestId);
+            reject(new Error(timeoutMessage));
+        }, timeoutMs);
+        pendingRequests.set(requestId, {
+            staleMessage,
+            resolve: (value)=>{
+                clearTimeout(timeoutId);
+                resolve(value);
+            },
+            reject: (error)=>{
+                clearTimeout(timeoutId);
+                reject(error);
+            }
+        });
+        window.parent.postMessage({
+            type: DISPATCH_MESSAGE_TYPE,
+            payload: {
+                type: DISPATCH_RPC_REQUEST_TYPE,
+                payload: request
+            }
+        }, '*');
+    });
+};
+const getUrlSearchParam = (name)=>{
+    try {
+        const value = new URL(window.location.href).searchParams.get(name);
+        return value ?? void 0;
+    } catch  {
+        return;
+    }
+};
+const getCurrentTestPath = ()=>{
+    const testPath = window.__RSTEST_BROWSER_OPTIONS__?.testFile ?? getUrlSearchParam('testFile');
+    if (!testPath) throw new Error("Browser RPC requires testFile in __RSTEST_BROWSER_OPTIONS__. This usually indicates the runner iframe was not configured by the container or URL.");
+    return testPath;
+};
+const getCurrentRunId = ()=>{
+    const runId = window.__RSTEST_BROWSER_OPTIONS__?.runId ?? getUrlSearchParam('runId');
+    if (!runId) throw new Error("Browser RPC requires runId in __RSTEST_BROWSER_OPTIONS__. This usually indicates the runner iframe URL/config is stale or incomplete.");
+    return runId;
+};
+const createBrowserDispatchRequest = (requestId, request)=>({
+        requestId,
+        namespace: DISPATCH_NAMESPACE_BROWSER,
+        method: DISPATCH_METHOD_RPC,
+        args: request,
+        target: {
+            testFile: request.testPath
+        }
+    });
+const callBrowserRpc = async (payload)=>{
+    if ('config' === payload.kind && window.__RSTEST_BROWSER_OPTIONS__?.mode === 'collect') return;
+    const id = createRequestId('browser-rpc');
+    const rpcTimeout = getRpcTimeout();
+    const request = {
+        id,
+        testPath: getCurrentTestPath(),
+        runId: getCurrentRunId(),
+        ...payload
+    };
+    const dispatchRequest = createBrowserDispatchRequest(id, request);
+    return dispatchRpc({
+        requestId: id,
+        request: dispatchRequest,
+        timeoutMs: rpcTimeout,
+        staleMessage: 'Stale browser RPC request ignored.',
+        timeoutMessage: `Browser RPC timeout after ${rpcTimeout / 1000}s: ${request.kind}.${request.method}`
+    });
+};
+const serializeText = (value)=>{
+    if ('string' == typeof value) return {
+        type: 'string',
+        value
+    };
+    return {
+        type: 'regexp',
+        source: value.source,
+        flags: value.flags
+    };
+};
+class Locator {
+    ir;
+    constructor(ir){
+        this.ir = ir;
+    }
+    getByRole(role, options) {
+        const next = {
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByRole',
+                    role,
+                    options: options ? {
+                        ...options,
+                        name: void 0 === options.name ? void 0 : serializeText(options.name)
+                    } : void 0
+                }
+            ]
+        };
+        return new Locator(next);
+    }
+    locator(selector) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'locator',
+                    selector
+                }
+            ]
+        });
+    }
+    getByText(text, options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByText',
+                    text: serializeText(text),
+                    options
+                }
+            ]
+        });
+    }
+    getByLabel(text, options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByLabel',
+                    text: serializeText(text),
+                    options
+                }
+            ]
+        });
+    }
+    getByPlaceholder(text, options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByPlaceholder',
+                    text: serializeText(text),
+                    options
+                }
+            ]
+        });
+    }
+    getByAltText(text, options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByAltText',
+                    text: serializeText(text),
+                    options
+                }
+            ]
+        });
+    }
+    getByTitle(text, options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByTitle',
+                    text: serializeText(text),
+                    options
+                }
+            ]
+        });
+    }
+    getByTestId(text) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'getByTestId',
+                    text: serializeText(text)
+                }
+            ]
+        });
+    }
+    filter(options) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'filter',
+                    options: {
+                        hasText: options.hasText ? serializeText(options.hasText) : void 0,
+                        hasNotText: options.hasNotText ? serializeText(options.hasNotText) : void 0,
+                        has: void 0 === options.has ? void 0 : isLocator(options.has) ? options.has.ir : (()=>{
+                            throw new TypeError('Locator.filter({ has }) expects a Locator returned from @rstest/browser page.getBy* APIs.');
+                        })(),
+                        hasNot: void 0 === options.hasNot ? void 0 : isLocator(options.hasNot) ? options.hasNot.ir : (()=>{
+                            throw new TypeError('Locator.filter({ hasNot }) expects a Locator returned from @rstest/browser page.getBy* APIs.');
+                        })()
+                    }
+                }
+            ]
+        });
+    }
+    and(other) {
+        if (!isLocator(other)) throw new TypeError('Locator.and() expects a Locator returned from @rstest/browser page.getBy* APIs.');
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'and',
+                    locator: other.ir
+                }
+            ]
+        });
+    }
+    or(other) {
+        if (!isLocator(other)) throw new TypeError('Locator.or() expects a Locator returned from @rstest/browser page.getBy* APIs.');
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'or',
+                    locator: other.ir
+                }
+            ]
+        });
+    }
+    nth(index) {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'nth',
+                    index
+                }
+            ]
+        });
+    }
+    first() {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'first'
+                }
+            ]
+        });
+    }
+    last() {
+        return new Locator({
+            steps: [
+                ...this.ir.steps,
+                {
+                    type: 'last'
+                }
+            ]
+        });
+    }
+    async click(options) {
+        await this.callLocator('click', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async dblclick(options) {
+        await this.callLocator('dblclick', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async fill(value, options) {
+        await this.callLocator('fill', void 0 === options ? [
+            value
+        ] : [
+            value,
+            options
+        ]);
+    }
+    async hover(options) {
+        await this.callLocator('hover', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async press(key, options) {
+        await this.callLocator('press', void 0 === options ? [
+            key
+        ] : [
+            key,
+            options
+        ]);
+    }
+    async clear() {
+        await this.callLocator('clear', []);
+    }
+    async check(options) {
+        await this.callLocator('check', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async uncheck(options) {
+        await this.callLocator('uncheck', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async focus(options) {
+        await this.callLocator('focus', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async blur(options) {
+        await this.callLocator('blur', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async scrollIntoViewIfNeeded(options) {
+        await this.callLocator('scrollIntoViewIfNeeded', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async waitFor(options) {
+        await this.callLocator('waitFor', void 0 === options ? [] : [
+            options
+        ]);
+    }
+    async dispatchEvent(type, eventInit) {
+        if ('string' != typeof type || !type) throw new TypeError('Locator.dispatchEvent() expects a non-empty event type string.');
+        await this.callLocator('dispatchEvent', void 0 === eventInit ? [
+            type
+        ] : [
+            type,
+            eventInit
+        ]);
+    }
+    async selectOption(value, options) {
+        if ('string' != typeof value && !(Array.isArray(value) && value.every((v)=>'string' == typeof v))) throw new TypeError('Locator.selectOption() only supports string or string[] values in browser mode.');
+        await this.callLocator('selectOption', void 0 === options ? [
+            value
+        ] : [
+            value,
+            options
+        ]);
+    }
+    async setInputFiles(files, options) {
+        if ('string' != typeof files && !(Array.isArray(files) && files.every((v)=>'string' == typeof v))) throw new TypeError('Locator.setInputFiles() only supports file path string or string[] in browser mode.');
+        await this.callLocator('setInputFiles', void 0 === options ? [
+            files
+        ] : [
+            files,
+            options
+        ]);
+    }
+    async callLocator(method, args) {
+        await callBrowserRpc({
+            kind: 'locator',
+            locator: this.ir,
+            method,
+            args
+        });
+    }
+}
+const browserPageQueryMethods = [
+    'locator',
+    'getByRole',
+    'getByText',
+    'getByLabel',
+    'getByPlaceholder',
+    'getByAltText',
+    'getByTitle',
+    'getByTestId'
+];
+const rootLocator = new Locator({
+    steps: []
+});
+const createBrowserPage = ()=>Object.fromEntries(browserPageQueryMethods.map((methodName)=>[
+            methodName,
+            rootLocator[methodName].bind(rootLocator)
+        ]));
+const page = createBrowserPage();
+const isLocator = (value)=>value instanceof Locator;
+const setTestIdAttribute = async (attribute)=>{
+    await callBrowserRpc({
+        kind: 'config',
+        locator: {
+            steps: []
+        },
+        method: 'setTestIdAttribute',
+        args: [
+            attribute
+        ]
+    });
+};
+const serializeMatcherText = (value)=>serializeText(value);
+const createElementExpect = (locator, isNot)=>{
+    const callExpect = async (method, args, timeout)=>{
+        await callBrowserRpc({
+            kind: 'expect',
+            locator: locator.ir,
+            method,
+            args,
+            isNot,
+            timeout
+        });
+    };
+    const api = {
+        async toBeVisible (options) {
+            await callExpect('toBeVisible', [], options?.timeout);
+        },
+        async toBeHidden (options) {
+            await callExpect('toBeHidden', [], options?.timeout);
+        },
+        async toBeEnabled (options) {
+            await callExpect('toBeEnabled', [], options?.timeout);
+        },
+        async toBeDisabled (options) {
+            await callExpect('toBeDisabled', [], options?.timeout);
+        },
+        async toBeChecked (options) {
+            await callExpect('toBeChecked', [], options?.timeout);
+        },
+        async toBeUnchecked (options) {
+            await callExpect('toBeUnchecked', [], options?.timeout);
+        },
+        async toBeAttached (options) {
+            await callExpect('toBeAttached', [], options?.timeout);
+        },
+        async toBeDetached (options) {
+            await callExpect('toBeDetached', [], options?.timeout);
+        },
+        async toBeEditable (options) {
+            await callExpect('toBeEditable', [], options?.timeout);
+        },
+        async toBeFocused (options) {
+            await callExpect('toBeFocused', [], options?.timeout);
+        },
+        async toBeEmpty (options) {
+            await callExpect('toBeEmpty', [], options?.timeout);
+        },
+        async toBeInViewport (options) {
+            const ratio = options?.ratio;
+            await callExpect('toBeInViewport', void 0 === ratio ? [] : [
+                ratio
+            ], options?.timeout);
+        },
+        async toHaveText (text, options) {
+            await callExpect('toHaveText', [
+                serializeMatcherText(text)
+            ], options?.timeout);
+        },
+        async toContainText (text, options) {
+            await callExpect('toContainText', [
+                serializeMatcherText(text)
+            ], options?.timeout);
+        },
+        async toHaveValue (value, options) {
+            await callExpect('toHaveValue', [
+                serializeMatcherText(value)
+            ], options?.timeout);
+        },
+        async toHaveId (value, options) {
+            await callExpect('toHaveId', [
+                serializeMatcherText(value)
+            ], options?.timeout);
+        },
+        async toHaveAttribute (name, value, options) {
+            const args = void 0 === value ? [
+                name
+            ] : [
+                name,
+                serializeMatcherText(value)
+            ];
+            await callExpect('toHaveAttribute', args, options?.timeout);
+        },
+        async toHaveClass (value, options) {
+            await callExpect('toHaveClass', [
+                serializeMatcherText(value)
+            ], options?.timeout);
+        },
+        async toHaveCount (count, options) {
+            await callExpect('toHaveCount', [
+                count
+            ], options?.timeout);
+        },
+        async toHaveCSS (name, value, options) {
+            if ('string' != typeof name || !name) throw new TypeError('toHaveCSS expects a non-empty CSS property name');
+            await callExpect('toHaveCSS', [
+                name,
+                serializeMatcherText(value)
+            ], options?.timeout);
+        },
+        async toHaveJSProperty (name, value, options) {
+            if ('string' != typeof name || !name) throw new TypeError('toHaveJSProperty expects a non-empty property name');
+            await callExpect('toHaveJSProperty', [
+                name,
+                value
+            ], options?.timeout);
+        }
+    };
+    const withNot = api;
+    Object.defineProperty(withNot, 'not', {
+        configurable: false,
+        enumerable: false,
+        get () {
+            return createElementExpect(locator, !isNot);
+        }
+    });
+    return withNot;
+};
+const api_element = (locator)=>{
+    if (!isLocator(locator)) throw new TypeError('expect.element() expects a Locator returned from @rstest/browser page.getBy* APIs.');
+    return createElementExpect(locator, false);
+};
+const markBrowserElement = ()=>{
+    Object.defineProperty(api_element, '__rstestBrowser', {
+        value: true,
+        configurable: false,
+        enumerable: false,
+        writable: false
+    });
+};
+const installExpectElement = ()=>{
+    const api = globalThis.RSTEST_API;
+    const target = api?.expect;
+    if (!target) throw new Error('RSTEST_API.expect is not registered yet. This usually indicates @rstest/browser was imported too early.');
+    if ('function' != typeof target.element || !target.element.__rstestBrowser) {
+        markBrowserElement();
+        target.element = api_element;
+    }
+};
+installExpectElement();
+export { Locator, page, setTestIdAttribute };

package/dist/browserRpcRegistry.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+/**
+ * Runtime allowlists for Browser RPC methods.
+ *
+ * Planned capabilities are intentionally documented in comments (not runtime
+ * data) to keep this module focused on host-side validation.
+ *
+ * Planned gaps (non-exhaustive):
+ * - Locator query/interop: filter({ hasNot, hasNotText }), locator.selector/length,
+ *   locator.query()/element()/elements()/all(), page.elementLocator(element),
+ *   locators.extend(...)
+ * - Locator actions: tripleClick, hover out, drag/drop helpers
+ * - Assertions: a11y matchers (accessible name/description), toHaveRole,
+ *   toHaveValues
+ * - Artifacts intentionally excluded for now: screenshot/toMatchScreenshot/
+ *   trace/video
+ */
+export declare const supportedLocatorActions: Set<string>;
+export declare const supportedExpectElementMatchers: Set<string>;

package/dist/client/api.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Locator, page, setTestIdAttribute } from './locator';
+export type { BrowserPage, BrowserSerializable, LocatorBlurOptions, LocatorCheckOptions, LocatorClickOptions, LocatorDblclickOptions, LocatorDispatchEventInit, LocatorFillOptions, LocatorFilterOptions, LocatorFocusOptions, LocatorGetByRoleOptions, LocatorHoverOptions, LocatorKeyboardModifier, LocatorMouseButton, LocatorPosition, LocatorPressOptions, LocatorScrollIntoViewIfNeededOptions, LocatorSelectOptionOptions, LocatorSetInputFilesOptions, LocatorTextOptions, LocatorWaitForOptions, } from './locator';
+export { Locator, page, setTestIdAttribute };

package/dist/client/browserRpc.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { BrowserRpcRequest } from '../rpcProtocol';
2	+ export declare const callBrowserRpc: <T>(payload: Omit<BrowserRpcRequest, "id" \| "testPath" \| "runId">) => Promise<T>;

package/dist/client/dispatchTransport.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import type { BrowserDispatchRequest } from '../protocol';
+export declare const DEFAULT_RPC_TIMEOUT_MS = 30000;
+export declare const getRpcTimeout: () => number;
+export declare const createRequestId: (prefix: string) => string;
+export declare const dispatchRpc: <T>({ requestId, request, timeoutMs, timeoutMessage, staleMessage, }: {
+    requestId: string;
+    request: BrowserDispatchRequest;
+    timeoutMs: number;
+    timeoutMessage: string;
+    staleMessage: string;
+}) => Promise<T>;