@testspectra/matchers 1.1.8-rc.20 → 1.1.8-rc.21

package/dist/reporter.js

@@ -67,19 +67,7 @@ export function formatArgs(args) {
  */
 export async function trackCommand(category, commandText, fn) {
     const start = Date.now();
-    const payloadObj = typeof commandText === 'object' ? { ...commandText } : { text: commandText };
-    if (typeof globalThis !== 'undefined') {
-        const g = globalThis;
-        const currentTest = g.__CURRENT_TEST_TITLE__ || g.__CURRENT_TEST_ID__;
-        if (currentTest && !payloadObj.test) {
-            payloadObj.test = currentTest;
-        }
-        const workerId = g.__TESTSPECTRA_WORKER_ID__;
-        if (workerId !== undefined && payloadObj.workerId === undefined) {
-            payloadObj.workerId = workerId;
-        }
-    }
-    const payload = JSON.stringify(payloadObj);
+    const payload = typeof commandText === 'object' ? JSON.stringify(commandText) : commandText;
     console.log(`[TESTSPECTRA_STEP_START] ${payload}`);
     try {
         const result = await fn();

package/dist/runner/collection.js

@@ -84,22 +84,9 @@ export class MultiElementRunner {
     eq(index) {
         const targetSelector = `${this._selector}[${index}]`;
         const elPromise = (async () => {
-            const getElements = typeof $$ !== 'undefined' ? $$ : globalThis.$$;
-            if (typeof getElements === 'function') {
-                const elements = await getElements(this._selector);
-                if (typeof elements?.nth === 'function') {
-                    return elements.nth(index);
-                }
-                if (index === 0 && typeof elements?.first === 'function') {
-                    return elements.first();
-                }
-                if (elements && elements[index] !== undefined) {
-                    return elements[index];
-                }
-            }
-            const getDollar = typeof $ !== 'undefined' ? $ : globalThis.$;
-            if (typeof getDollar === 'function') {
-                return getDollar(targetSelector);
+            if (typeof $$ !== 'undefined') {
+                const elements = await $$(this._selector);
+                return elements[index];
             }
             return { selector: targetSelector };
         })();
@@ -130,23 +117,10 @@ export class MultiElementRunner {
     last() {
         const targetSelector = `${this._selector}[last()]`;
         const elPromise = (async () => {
-            const getElements = typeof $$ !== 'undefined' ? $$ : globalThis.$$;
-            if (typeof getElements === 'function') {
-                const elements = await getElements(this._selector);
-                if (typeof elements?.last === 'function') {
-                    return elements.last();
-                }
-                if (typeof elements?.nth === 'function') {
-                    return elements.nth(-1);
-                }
+            if (typeof $$ !== 'undefined') {
+                const elements = await $$(this._selector);
                 const arr = Array.isArray(elements) ? elements : await elements;
-                if (arr && arr.length > 0) {
-                    return arr[arr.length - 1];
-                }
-            }
-            const getDollar = typeof $ !== 'undefined' ? $ : globalThis.$;
-            if (typeof getDollar === 'function') {
-                return getDollar(targetSelector);
+                return arr[arr.length - 1];
             }
             return { selector: targetSelector };
         })();

package/dist/runner/single.d.ts

@@ -90,11 +90,11 @@ export declare class SingleElementRunner implements PromiseLike<void>, ElementRe
      */
     select(value: string): this;
     /**
-     * Hovers over the target element.
+     * Moves the mouse cursor over the target element (hover).
      *
      * @example
      * ```ts
-     * await Spectra.get("#dropdown-trigger").hover();
+     * await Spectra.get("#dropdown-menu-trigger").hover();
      * ```
      * @returns Current runner instance for method chaining.
      */

package/dist/runner/single.js

@@ -120,17 +120,9 @@ export class SingleElementRunner {
         this._action = async () => {
             const el = await resolveElement(target);
             if (options?.clearFirst) {
-                if (typeof el.clearValue === 'function')
-                    await el.clearValue();
-                else if (typeof el.clear === 'function')
-                    await el.clear();
+                await el.clearValue();
             }
-            if (typeof el.setValue === 'function')
-                await el.setValue(value);
-            else if (typeof el.fill === 'function')
-                await el.fill(value);
-            else if (typeof el.type === 'function')
-                await el.type(value);
+            await el.setValue(value);
         };
         return this;
     }
@@ -148,10 +140,7 @@ export class SingleElementRunner {
         this._actionPayload = { type: 'action', key: 'clear', target: getRawTarget(target), args: [] };
         this._action = async () => {
             const el = await resolveElement(target);
-            if (typeof el.clearValue === 'function')
-                await el.clearValue();
-            else if (typeof el.clear === 'function')
-                await el.clear();
+            await el.clearValue();
         };
         return this;
     }
@@ -170,19 +159,16 @@ export class SingleElementRunner {
         this._actionPayload = { type: 'action', key: 'selectOption', target: getRawTarget(target), args: [value] };
         this._action = async () => {
             const el = await resolveElement(target);
-            if (typeof el.selectByVisibleText === 'function')
-                await el.selectByVisibleText(value);
-            else if (typeof el.selectOption === 'function')
-                await el.selectOption({ label: value });
+            await el.selectByVisibleText(value);
         };
         return this;
     }
     /**
-     * Hovers over the target element.
+     * Moves the mouse cursor over the target element (hover).
      *
      * @example
      * ```ts
-     * await Spectra.get("#dropdown-trigger").hover();
+     * await Spectra.get("#dropdown-menu-trigger").hover();
      * ```
      * @returns Current runner instance for method chaining.
      */
@@ -191,10 +177,7 @@ export class SingleElementRunner {
         this._actionPayload = { type: 'action', key: 'hover', target: getRawTarget(target), args: [] };
         this._action = async () => {
             const el = await resolveElement(target);
-            if (typeof el.moveTo === 'function')
-                await el.moveTo();
-            else if (typeof el.hover === 'function')
-                await el.hover();
+            await el.moveTo();
         };
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testspectra/matchers",
-  "version": "1.1.8-rc.20",
+  "version": "1.1.8-rc.21",
   "description": "Canonical TypeScript contracts and ambient type definitions for TestSpectra",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/__tests__/matcher-contracts.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/matcher-contracts.test.js

@@ -1,498 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-// Helper polling simulation resembling worker.ts pollCondition
-async function pollCondition(fn, timeoutMs = 100, intervalMs = 10) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        try {
-            if (await fn())
-                return true;
-        }
-        catch { }
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-    try {
-        return await fn();
-    }
-    catch {
-        return false;
-    }
-}
-// Factory to create a test SingleElementProxy backed by simulated DOM element state
-function createTestElementProxy(selector, state) {
-    const proxy = {
-        selector,
-        async isDisplayed() {
-            return state.displayed ?? true;
-        },
-        async isExisting() {
-            return state.existing ?? true;
-        },
-        async isEnabled() {
-            return state.enabled ?? true;
-        },
-        async isSelected() {
-            return state.selected ?? false;
-        },
-        async isFocused() {
-            return state.focused ?? false;
-        },
-        async getText() {
-            return state.text ?? '';
-        },
-        async getValue() {
-            return state.value ?? '';
-        },
-        async getAttribute(name) {
-            return state.attributes?.[name] ?? null;
-        },
-        async getCSSProperty(property) {
-            return { property, value: state.css?.[property] ?? '', parsed: {} };
-        },
-        async click() { },
-        async doubleClick() { },
-        async rightClick() { },
-        async hover() { },
-        async focus() { },
-        async clear() { },
-        async type(_text) { },
-        async select(_option) { },
-        async selectByAttribute(_attribute, _value) { },
-        async selectByValue(_value) { },
-        async selectByIndex(_index) { },
-        async selectByVisibleText(_text) { },
-        async dragDrop(_destination) { },
-        async scrollIntoView() { },
-        async swipe(_options) { },
-        async longPress(_options) { },
-        async waitForElement(_timeoutMs) { },
-        async waitForExist(_timeoutMs) { },
-        async waitForDisplayed(_timeoutMs) { },
-        async waitForEnabled(_timeoutMs) { },
-        // Matcher implementations identical to worker.ts logic
-        async shouldBeVisible() {
-            const ok = await pollCondition(async () => await this.isDisplayed());
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to be visible`);
-        },
-        async shouldNotBeVisible() {
-            const ok = await pollCondition(async () => !(await this.isDisplayed()));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to be visible`);
-        },
-        async shouldExist() {
-            const ok = await pollCondition(async () => await this.isExisting());
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to exist in DOM`);
-        },
-        async shouldNotExist() {
-            const ok = await pollCondition(async () => !(await this.isExisting()));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to exist in DOM`);
-        },
-        async shouldBeEnabled() {
-            const ok = await pollCondition(async () => await this.isEnabled());
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to be enabled`);
-        },
-        async shouldBeDisabled() {
-            const ok = await pollCondition(async () => !(await this.isEnabled()));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to be disabled`);
-        },
-        async shouldBeChecked() {
-            const ok = await pollCondition(async () => await this.isSelected());
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to be checked`);
-        },
-        async shouldNotBeChecked() {
-            const ok = await pollCondition(async () => !(await this.isSelected()));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to be checked`);
-        },
-        async shouldBeFocused() {
-            const ok = await pollCondition(async () => await this.isFocused());
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to be focused`);
-        },
-        async shouldNotBeFocused() {
-            const ok = await pollCondition(async () => !(await this.isFocused()));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to be focused`);
-        },
-        async shouldHaveText(expected) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getText();
-                if (expected instanceof RegExp)
-                    return expected.test(actual);
-                return actual === String(expected) || actual.trim() === String(expected).trim();
-            });
-            if (!ok) {
-                if (expected instanceof RegExp)
-                    throw new Error(`Expected element "${selector}" text to match ${expected}, but got "${actual}"`);
-                throw new Error(`Expected element "${selector}" to have text "${expected}", but got "${actual}"`);
-            }
-        },
-        async shouldNotHaveText(expected) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getText();
-                if (expected instanceof RegExp)
-                    return !expected.test(actual);
-                return actual !== String(expected) && actual.trim() !== String(expected).trim();
-            });
-            if (!ok) {
-                if (expected instanceof RegExp)
-                    throw new Error(`Expected element "${selector}" text not to match ${expected}`);
-                throw new Error(`Expected element "${selector}" not to have text "${expected}"`);
-            }
-        },
-        async shouldContainText(substring) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getText();
-                return actual.includes(String(substring));
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to contain text "${substring}", but got "${actual}"`);
-        },
-        async shouldNotContainText(substring) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getText();
-                return !actual.includes(String(substring));
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to contain text "${substring}"`);
-        },
-        async shouldHaveValue(value) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getValue();
-                return actual === String(value);
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to have value "${value}", but got "${actual}"`);
-        },
-        async shouldNotHaveValue(value) {
-            const ok = await pollCondition(async () => {
-                const actual = await this.getValue();
-                return actual !== String(value);
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to have value "${value}"`);
-        },
-        async shouldContainValue(value) {
-            let actual = '';
-            const ok = await pollCondition(async () => {
-                actual = await this.getValue();
-                return actual.includes(String(value));
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to contain value "${value}", but got "${actual}"`);
-        },
-        async shouldNotContainValue(value) {
-            const ok = await pollCondition(async () => {
-                const actual = await this.getValue();
-                return !actual.includes(String(value));
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to contain value "${value}"`);
-        },
-        async shouldHaveClass(className) {
-            const ok = await pollCondition(async () => state.classes?.includes(className) ?? false);
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to have class "${className}"`);
-        },
-        async shouldNotHaveClass(className) {
-            const ok = await pollCondition(async () => !(state.classes?.includes(className) ?? false));
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to have class "${className}"`);
-        },
-        async shouldHaveAttribute(name, value) {
-            let actual = null;
-            const ok = await pollCondition(async () => {
-                actual = await this.getAttribute(name);
-                if (value !== undefined)
-                    return actual === String(value);
-                return actual !== null;
-            });
-            if (!ok) {
-                if (value !== undefined)
-                    throw new Error(`Expected element "${selector}" to have attribute "${name}" = "${value}", but got "${actual}"`);
-                throw new Error(`Expected element "${selector}" to have attribute "${name}"`);
-            }
-        },
-        async shouldNotHaveAttribute(name) {
-            const ok = await pollCondition(async () => {
-                const actual = await this.getAttribute(name);
-                return actual === null;
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to have attribute "${name}"`);
-        },
-        async shouldHaveCss(property, value) {
-            let actualCss = '';
-            const ok = await pollCondition(async () => {
-                const css = await this.getCSSProperty(property);
-                actualCss = css.value;
-                return actualCss === value;
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" to have CSS "${property}" = "${value}", but got "${actualCss}"`);
-        },
-        async shouldNotHaveCss(property, value) {
-            const ok = await pollCondition(async () => {
-                const css = await this.getCSSProperty(property);
-                return css.value !== value;
-            });
-            if (!ok)
-                throw new Error(`Expected element "${selector}" not to have CSS "${property}" = "${value}"`);
-        },
-    };
-    return proxy;
-}
-// Factory to create a test CollectionProxy backed by simulated count
-function createTestCollectionProxy(selector, itemsCount) {
-    return {
-        selector,
-        async count() {
-            return itemsCount;
-        },
-        get length() {
-            return this.count();
-        },
-        first() {
-            return createTestElementProxy(`${selector}:first-child`, {});
-        },
-        last() {
-            return createTestElementProxy(`${selector}:last-child`, {});
-        },
-        nth(index) {
-            return createTestElementProxy(`${selector}:nth-child(${index})`, {});
-        },
-        async shouldHaveLength(expected) {
-            let actual = 0;
-            const ok = await pollCondition(async () => {
-                actual = await this.count();
-                return actual === expected;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" count to equal ${expected}, but got ${actual}`);
-        },
-        async shouldNotHaveLength(expected) {
-            const ok = await pollCondition(async () => {
-                const actual = await this.count();
-                return actual !== expected;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" count not to equal ${expected}`);
-        },
-        async shouldHaveLengthGreaterThan(expected) {
-            let actual = 0;
-            const ok = await pollCondition(async () => {
-                actual = await this.count();
-                return actual > expected;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" count to be greater than ${expected}, but got ${actual}`);
-        },
-        async shouldHaveLengthLessThan(expected) {
-            let actual = 0;
-            const ok = await pollCondition(async () => {
-                actual = await this.count();
-                return actual < expected;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" count to be less than ${expected}, but got ${actual}`);
-        },
-        async shouldBeEmpty() {
-            let actual = 0;
-            const ok = await pollCondition(async () => {
-                actual = await this.count();
-                return actual === 0;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" to be empty, but got ${actual}`);
-        },
-        async shouldNotBeEmpty() {
-            const ok = await pollCondition(async () => {
-                const actual = await this.count();
-                return actual > 0;
-            });
-            if (!ok)
-                throw new Error(`Expected collection "${selector}" not to be empty`);
-        },
-    };
-}
-describe('Worker Matchers & Static Actions Verification Suite', () => {
-    describe('Single Element Visibility & Existence Matchers', () => {
-        it('passes shouldBeVisible when element is displayed, fails and throws when not displayed', async () => {
-            const visibleEl = createTestElementProxy('#btn-visible', { displayed: true });
-            await expect(visibleEl.shouldBeVisible()).resolves.toBeUndefined();
-            const hiddenEl = createTestElementProxy('#btn-hidden', { displayed: false });
-            await expect(hiddenEl.shouldBeVisible()).rejects.toThrow('Expected element "#btn-hidden" to be visible');
-        });
-        it('passes shouldNotBeVisible when element is hidden, fails and throws when displayed', async () => {
-            const hiddenEl = createTestElementProxy('#btn-hidden', { displayed: false });
-            await expect(hiddenEl.shouldNotBeVisible()).resolves.toBeUndefined();
-            const visibleEl = createTestElementProxy('#btn-visible', { displayed: true });
-            await expect(visibleEl.shouldNotBeVisible()).rejects.toThrow('Expected element "#btn-visible" not to be visible');
-        });
-        it('passes shouldExist when element is in DOM, fails and throws when missing', async () => {
-            const domEl = createTestElementProxy('#card', { existing: true });
-            await expect(domEl.shouldExist()).resolves.toBeUndefined();
-            const missingEl = createTestElementProxy('#missing-card', { existing: false });
-            await expect(missingEl.shouldExist()).rejects.toThrow('Expected element "#missing-card" to exist in DOM');
-        });
-        it('passes shouldNotExist when element is missing, fails and throws when element exists', async () => {
-            const missingEl = createTestElementProxy('#missing-card', { existing: false });
-            await expect(missingEl.shouldNotExist()).resolves.toBeUndefined();
-            const domEl = createTestElementProxy('#card', { existing: true });
-            await expect(domEl.shouldNotExist()).rejects.toThrow('Expected element "#card" not to exist in DOM');
-        });
-    });
-    describe('Single Element State Matchers (Enabled, Checked, Focused)', () => {
-        it('verifies shouldBeEnabled and shouldBeDisabled strictly', async () => {
-            const enabledEl = createTestElementProxy('#submit-btn', { enabled: true });
-            await expect(enabledEl.shouldBeEnabled()).resolves.toBeUndefined();
-            await expect(enabledEl.shouldBeDisabled()).rejects.toThrow('Expected element "#submit-btn" to be disabled');
-            const disabledEl = createTestElementProxy('#disabled-btn', { enabled: false });
-            await expect(disabledEl.shouldBeDisabled()).resolves.toBeUndefined();
-            await expect(disabledEl.shouldBeEnabled()).rejects.toThrow('Expected element "#disabled-btn" to be enabled');
-        });
-        it('verifies shouldBeChecked and shouldNotBeChecked strictly', async () => {
-            const checkedCheckbox = createTestElementProxy('#agree', { selected: true });
-            await expect(checkedCheckbox.shouldBeChecked()).resolves.toBeUndefined();
-            await expect(checkedCheckbox.shouldNotBeChecked()).rejects.toThrow('Expected element "#agree" not to be checked');
-            const uncheckedCheckbox = createTestElementProxy('#disagree', { selected: false });
-            await expect(uncheckedCheckbox.shouldNotBeChecked()).resolves.toBeUndefined();
-            await expect(uncheckedCheckbox.shouldBeChecked()).rejects.toThrow('Expected element "#disagree" to be checked');
-        });
-        it('verifies shouldBeFocused and shouldNotBeFocused strictly', async () => {
-            const focusedInput = createTestElementProxy('#email-input', { focused: true });
-            await expect(focusedInput.shouldBeFocused()).resolves.toBeUndefined();
-            await expect(focusedInput.shouldNotBeFocused()).rejects.toThrow('Expected element "#email-input" not to be focused');
-            const unfocusedInput = createTestElementProxy('#password-input', { focused: false });
-            await expect(unfocusedInput.shouldNotBeFocused()).resolves.toBeUndefined();
-            await expect(unfocusedInput.shouldBeFocused()).rejects.toThrow('Expected element "#password-input" to be focused');
-        });
-    });
-    describe('Content Matchers (Text, Value, Classes, Attributes, CSS)', () => {
-        it('strictly checks text equality and fails on mismatch', async () => {
-            const textEl = createTestElementProxy('#heading', { text: 'Welcome to TestSpectra' });
-            await expect(textEl.shouldHaveText('Welcome to TestSpectra')).resolves.toBeUndefined();
-            await expect(textEl.shouldHaveText(/Welcome to \w+/)).resolves.toBeUndefined();
-            await expect(textEl.shouldContainText('TestSpectra')).resolves.toBeUndefined();
-            // Negative assertions
-            await expect(textEl.shouldNotHaveText('Goodbye')).resolves.toBeUndefined();
-            await expect(textEl.shouldNotContainText('Cypress')).resolves.toBeUndefined();
-            // Failing conditions MUST throw and not falsely pass
-            await expect(textEl.shouldHaveText('Wrong Text')).rejects.toThrow('Expected element "#heading" to have text "Wrong Text", but got "Welcome to TestSpectra"');
-            await expect(textEl.shouldContainText('Selenium')).rejects.toThrow('Expected element "#heading" to contain text "Selenium", but got "Welcome to TestSpectra"');
-            await expect(textEl.shouldNotHaveText('Welcome to TestSpectra')).rejects.toThrow('Expected element "#heading" not to have text "Welcome to TestSpectra"');
-            await expect(textEl.shouldNotContainText('TestSpectra')).rejects.toThrow('Expected element "#heading" not to contain text "TestSpectra"');
-        });
-        it('strictly checks input values and fails on mismatch', async () => {
-            const inputEl = createTestElementProxy('#username', { value: 'admin_testspectra' });
-            await expect(inputEl.shouldHaveValue('admin_testspectra')).resolves.toBeUndefined();
-            await expect(inputEl.shouldContainValue('admin_')).resolves.toBeUndefined();
-            await expect(inputEl.shouldNotHaveValue('guest')).resolves.toBeUndefined();
-            await expect(inputEl.shouldNotContainValue('root')).resolves.toBeUndefined();
-            await expect(inputEl.shouldHaveValue('wrong_user')).rejects.toThrow('Expected element "#username" to have value "wrong_user", but got "admin_testspectra"');
-            await expect(inputEl.shouldNotHaveValue('admin_testspectra')).rejects.toThrow('Expected element "#username" not to have value "admin_testspectra"');
-        });
-        it('strictly checks classes and attributes', async () => {
-            const badge = createTestElementProxy('#status-badge', {
-                classes: ['badge', 'badge-success', 'active'],
-                attributes: { id: 'status-badge', 'data-role': 'indicator', disabled: 'false' },
-                css: { color: 'rgb(0, 128, 0)' },
-            });
-            await expect(badge.shouldHaveClass('badge-success')).resolves.toBeUndefined();
-            await expect(badge.shouldNotHaveClass('badge-danger')).resolves.toBeUndefined();
-            await expect(badge.shouldHaveAttribute('data-role', 'indicator')).resolves.toBeUndefined();
-            await expect(badge.shouldNotHaveAttribute('data-unknown')).resolves.toBeUndefined();
-            await expect(badge.shouldHaveCss('color', 'rgb(0, 128, 0)')).resolves.toBeUndefined();
-            // Fails when class/attribute is missing or incorrect
-            await expect(badge.shouldHaveClass('badge-danger')).rejects.toThrow('Expected element "#status-badge" to have class "badge-danger"');
-            await expect(badge.shouldNotHaveClass('badge-success')).rejects.toThrow('Expected element "#status-badge" not to have class "badge-success"');
-            await expect(badge.shouldHaveAttribute('data-role', 'wrong-val')).rejects.toThrow('Expected element "#status-badge" to have attribute "data-role" = "wrong-val", but got "indicator"');
-            await expect(badge.shouldNotHaveAttribute('data-role')).rejects.toThrow('Expected element "#status-badge" not to have attribute "data-role"');
-        });
-    });
-    describe('Collection Matchers ($$ / Spectra.getAll)', () => {
-        it('strictly checks collection lengths and emptiness', async () => {
-            const items = createTestCollectionProxy('.post-item', 5);
-            await expect(items.shouldHaveLength(5)).resolves.toBeUndefined();
-            await expect(items.shouldHaveLengthGreaterThan(3)).resolves.toBeUndefined();
-            await expect(items.shouldHaveLengthLessThan(10)).resolves.toBeUndefined();
-            await expect(items.shouldNotBeEmpty()).resolves.toBeUndefined();
-            // Failing conditions MUST throw
-            await expect(items.shouldHaveLength(0)).rejects.toThrow('Expected collection ".post-item" count to equal 0, but got 5');
-            await expect(items.shouldHaveLengthGreaterThan(10)).rejects.toThrow('Expected collection ".post-item" count to be greater than 10, but got 5');
-            await expect(items.shouldHaveLengthLessThan(3)).rejects.toThrow('Expected collection ".post-item" count to be less than 3, but got 5');
-            await expect(items.shouldBeEmpty()).rejects.toThrow('Expected collection ".post-item" to be empty, but got 5');
-            const emptyItems = createTestCollectionProxy('.empty-list', 0);
-            await expect(emptyItems.shouldBeEmpty()).resolves.toBeUndefined();
-            await expect(emptyItems.shouldNotBeEmpty()).rejects.toThrow('Expected collection ".empty-list" not to be empty');
-        });
-    });
-    describe('Spectra Static Automation API (Single Global Object)', () => {
-        it('correctly maps Spectra static methods to underlying actions without error', async () => {
-            const elementMock = createTestElementProxy('#test-btn', { text: 'Click Me', value: 'hello' });
-            const clickSpy = vi.spyOn(elementMock, 'click');
-            const typeSpy = vi.spyOn(elementMock, 'type');
-            const clearSpy = vi.spyOn(elementMock, 'clear');
-            const mockSpectra = {
-                get: (target) => (typeof target === 'string' ? elementMock : target),
-                getAll: (selector) => createTestCollectionProxy(selector, 2),
-                navigate: async (_url) => { },
-                back: async () => { },
-                forward: async () => { },
-                refresh: async () => { },
-                setViewport: async (_w, _h) => { },
-                wait: async (ms) => {
-                    await new Promise((r) => setTimeout(r, ms));
-                },
-                click: async (target) => {
-                    const el = typeof target === 'string' ? elementMock : target;
-                    await el.click();
-                },
-                doubleClick: async () => { },
-                rightClick: async () => { },
-                type: async (target, text) => {
-                    const el = typeof target === 'string' ? elementMock : target;
-                    await el.type(text);
-                },
-                clear: async (target) => {
-                    const el = typeof target === 'string' ? elementMock : target;
-                    await el.clear();
-                },
-                select: async () => { },
-                hover: async () => { },
-                dragDrop: async () => { },
-                scrollIntoView: async () => { },
-                scroll: async () => { },
-                swipe: async () => { },
-                longPress: async () => { },
-                pressKey: async () => { },
-                waitForElement: async () => { },
-                intercept: async () => ({ respondWith: async () => { }, callCount: () => 0 }),
-                clearMocks: () => { },
-                browser: {},
-            };
-            // Test actions call underlying proxy methods
-            await mockSpectra.click('#test-btn');
-            expect(clickSpy).toHaveBeenCalled();
-            await mockSpectra.type('#test-btn', 'Test input');
-            expect(typeSpy).toHaveBeenCalledWith('Test input');
-            await mockSpectra.clear('#test-btn');
-            expect(clearSpy).toHaveBeenCalled();
-            // Test wait execution timing
-            const start = Date.now();
-            await mockSpectra.wait(20);
-            const elapsed = Date.now() - start;
-            expect(elapsed).toBeGreaterThanOrEqual(15);
-        });
-    });
-});