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

package/src/runtime/assertions.ts

@@ -1,453 +1,454 @@
-/**
- * Fluent assertion matchers for `SingleElementProxy`.
- *
- * Each matcher polls the bound `PlatformDriverBridge` (or the delegated state getters) with
- * `trackStep('assertion')` instrumentation. There is zero `activePlatform` branching here —
- * platform-specific behavior lives entirely in the driver's `isClickable` / `hasClass` /
- * state-inspection methods.
- */
-
-import type { AssertionOptions, ScopedSelector } from '../types';
-
-export function createElementAssertions(
-  selector: string | ScopedSelector,
-  index: number | null,
-  state: Record<string, any>,
-): Record<string, any> {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-  const selectorText = typeof selector === 'string' ? selector : selector.selector;
-
-  async function shouldBeVisible(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.visible', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isVisible(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be visible`);
-      },
-    );
-  }
-
-  async function shouldNotBeVisible(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.visible', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isVisible()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be visible`);
-      },
-    );
-  }
-
-  async function shouldExist(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'exist', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isExisting(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to exist in DOM`);
-      },
-    );
-  }
-
-  async function shouldNotExist(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.exist', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isExisting()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to exist in DOM`);
-      },
-    );
-  }
-
-  async function shouldBeEnabled(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.enabled', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isEnabled(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be enabled`);
-      },
-    );
-  }
-
-  async function shouldBeDisabled(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.disabled', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isEnabled()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be disabled`);
-      },
-    );
-  }
-
-  async function shouldBeClickable(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.clickable', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => driver().isClickable(selector, index),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be clickable`);
-      },
-    );
-  }
-
-  async function shouldNotBeClickable(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.clickable', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await driver().isClickable(selector, index)),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be clickable`);
-      },
-    );
-  }
-
-  async function shouldBeChecked(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.checked', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isChecked(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be checked`);
-      },
-    );
-  }
-
-  async function shouldNotBeChecked(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.checked', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isChecked()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be checked`);
-      },
-    );
-  }
-
-  async function shouldBeFocused(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.focused', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isFocused(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be focused`);
-      },
-    );
-  }
-
-  async function shouldNotBeFocused(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.focused', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isFocused()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be focused`);
-      },
-    );
-  }
-
-  async function shouldHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.value', target: selector, args: [value] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getValue();
-          return actual === String(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" to have value "${value}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.value', target: selector, args: [value] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getValue();
-          return actual !== String(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have value "${value}"`);
-      },
-    );
-  }
-
-  async function shouldContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'contain.value', target: selector, args: [value] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getValue();
-          return actual.includes(String(value));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" to contain value "${value}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.contain.value', target: selector, args: [value] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getValue();
-          return !actual.includes(String(value));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain value "${value}"`);
-      },
-    );
-  }
-
-  async function shouldHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.text', target: selector, args: [expected] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getText();
-          if (expected instanceof RegExp) return expected.test(actual);
-          return actual === String(expected) || actual.trim() === String(expected).trim();
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (expected instanceof RegExp)
-            throw new Error(`Expected element "${selectorText}" text to match ${expected}, but got "${actual}"`);
-          throw new Error(`Expected element "${selectorText}" to have text "${expected}", but got "${actual}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldNotHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.text', target: selector, args: [expected] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          if (!(await state.isExisting())) return false;
-          actual = await state.getText();
-          if (expected instanceof RegExp) return !expected.test(actual);
-          return actual !== String(expected) && actual.trim() !== String(expected).trim();
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (expected instanceof RegExp)
-            throw new Error(`Expected element "${selectorText}" text not to match ${expected}`);
-          throw new Error(`Expected element "${selectorText}" not to have text "${expected}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldContainText(substring: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'contain.text', target: selector, args: [substring] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getText();
-          return actual.includes(String(substring));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" to contain text "${substring}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotContainText(substring: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.contain.text', target: selector, args: [substring] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getText();
-          return !actual.includes(String(substring));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain text "${substring}"`);
-      },
-    );
-  }
-
-  async function shouldHaveClass(className: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.class', target: selector, args: [className] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => driver().hasClass(selector, className, index),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to have class "${className}"`);
-      },
-    );
-  }
-
-  async function shouldNotHaveClass(className: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.class', target: selector, args: [className] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await driver().hasClass(selector, className, index)),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have class "${className}"`);
-      },
-    );
-  }
-
-  async function shouldHaveAttribute(name: string, value?: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.attr', target: selector, args: value !== undefined ? [name, value] : [name] },
-      async () => {
-        let actual: string | null = null;
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getAttribute(name);
-          if (value !== undefined) return actual === String(value);
-          return actual !== null;
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (value !== undefined)
-            throw new Error(
-              `Expected element "${selectorText}" to have attribute "${name}" = "${value}", but got "${actual}"`,
-            );
-          throw new Error(`Expected element "${selectorText}" to have attribute "${name}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldNotHaveAttribute(name: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.attr', target: selector, args: [name] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getAttribute(name);
-          return actual === null;
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have attribute "${name}"`);
-      },
-    );
-  }
-
-  async function shouldHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.css', target: selector, args: [property, value] },
-      async () => {
-        const norm = (v: any) =>
-          String(v ?? '')
-            .replace(/\s+/g, '')
-            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-            .toLowerCase();
-        let actualCss = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const css = await state.getCSSProperty(property);
-          actualCss = css.value;
-          return norm(actualCss) === norm(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok)
-          throw new Error(
-            `Expected element "${selectorText}" to have CSS "${property}" = "${value}", but got "${actualCss}"`,
-          );
-      },
-    );
-  }
-
-  async function shouldNotHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.css', target: selector, args: [property, value] },
-      async () => {
-        const norm = (v: any) =>
-          String(v ?? '')
-            .replace(/\s+/g, '')
-            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-            .toLowerCase();
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const css = await state.getCSSProperty(property);
-          return norm(css.value) !== norm(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have CSS "${property}" = "${value}"`);
-      },
-    );
-  }
-
-  return {
-    shouldBeVisible,
-    shouldNotBeVisible,
-    shouldExist,
-    shouldNotExist,
-    shouldBeEnabled,
-    shouldBeDisabled,
-    shouldBeClickable,
-    shouldNotBeClickable,
-    shouldBeChecked,
-    shouldNotBeChecked,
-    shouldBeFocused,
-    shouldNotBeFocused,
-    shouldHaveValue,
-    shouldNotHaveValue,
-    shouldContainValue,
-    shouldNotContainValue,
-    shouldHaveText,
-    shouldNotHaveText,
-    shouldContainText,
-    shouldNotContainText,
-    shouldHaveClass,
-    shouldNotHaveClass,
-    shouldHaveAttribute,
-    shouldNotHaveAttribute,
-    shouldHaveCss,
-    shouldNotHaveCss,
-  };
-}
-
-globalThis.__TS_RUNTIME__.createElementAssertions = createElementAssertions;
+/**
+ * Fluent assertion matchers for `SingleElementProxy`.
+ *
+ * Each matcher polls the bound `PlatformDriverBridge` (or the delegated state getters) with
+ * `trackStep('assertion')` instrumentation. There is zero `activePlatform` branching here —
+ * platform-specific behavior lives entirely in the driver's `isClickable` / `hasClass` /
+ * state-inspection methods.
+ */
+
+import type { AssertionOptions, ScopedSelector } from '../types.js';
+
+export function createElementAssertions(
+  selector: string | ScopedSelector,
+  index: number | null,
+  state: Record<string, any>,
+): Record<string, any> {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
+  const selectorText = typeof selector === 'string' ? selector : selector.selector;
+
+  async function shouldBeVisible(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.visible', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isVisible(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be visible`);
+      },
+    );
+  }
+
+  async function shouldNotBeVisible(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.be.visible', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await state.isVisible()),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to be visible`);
+      },
+    );
+  }
+
+  async function shouldExist(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'exist', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isExisting(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to exist in DOM`);
+      },
+    );
+  }
+
+  async function shouldNotExist(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.exist', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await state.isExisting()),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to exist in DOM`);
+      },
+    );
+  }
+
+  async function shouldBeEnabled(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.enabled', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isEnabled(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be enabled`);
+      },
+    );
+  }
+
+  async function shouldBeDisabled(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.disabled', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await state.isEnabled()),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be disabled`);
+      },
+    );
+  }
+
+  async function shouldBeClickable(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.clickable', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => driver().isClickable(selector, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be clickable`);
+      },
+    );
+  }
+
+  async function shouldNotBeClickable(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.be.clickable', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await driver().isClickable(selector, index)),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to be clickable`);
+      },
+    );
+  }
+
+  async function shouldBeChecked(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.checked', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isChecked(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be checked`);
+      },
+    );
+  }
+
+  async function shouldNotBeChecked(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.be.checked', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await state.isChecked()),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to be checked`);
+      },
+    );
+  }
+
+  async function shouldBeFocused(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'be.focused', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isFocused(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to be focused`);
+      },
+    );
+  }
+
+  async function shouldNotBeFocused(options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.be.focused', target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await state.isFocused()),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to be focused`);
+      },
+    );
+  }
+
+  async function shouldHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'have.value', target: selector, args: [value] },
+      async () => {
+        let actual = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getValue();
+          return actual === String(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" to have value "${value}", but got "${actual}"`);
+      },
+    );
+  }
+
+  async function shouldNotHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.have.value', target: selector, args: [value] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getValue();
+          return actual !== String(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to have value "${value}"`);
+      },
+    );
+  }
+
+  async function shouldContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'contain.value', target: selector, args: [value] },
+      async () => {
+        let actual = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getValue();
+          return actual.includes(String(value));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" to contain value "${value}", but got "${actual}"`);
+      },
+    );
+  }
+
+  async function shouldNotContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.contain.value', target: selector, args: [value] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getValue();
+          return !actual.includes(String(value));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain value "${value}"`);
+      },
+    );
+  }
+
+  async function shouldHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'have.text', target: selector, args: [expected] },
+      async () => {
+        let actual = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getText();
+          if (expected instanceof RegExp) return expected.test(actual);
+          return actual === String(expected) || actual.trim() === String(expected).trim();
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText}" text to match ${expected}, but got "${actual}"`);
+          throw new Error(`Expected element "${selectorText}" to have text "${expected}", but got "${actual}"`);
+        }
+      },
+    );
+  }
+
+  async function shouldNotHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.have.text', target: selector, args: [expected] },
+      async () => {
+        let actual = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          if (!(await state.isExisting())) return false;
+          actual = await state.getText();
+          if (expected instanceof RegExp) return !expected.test(actual);
+          return actual !== String(expected) && actual.trim() !== String(expected).trim();
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText}" text not to match ${expected}`);
+          throw new Error(`Expected element "${selectorText}" not to have text "${expected}"`);
+        }
+      },
+    );
+  }
+
+  async function shouldContainText(substring: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'contain.text', target: selector, args: [substring] },
+      async () => {
+        let actual = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getText();
+          return actual.includes(String(substring));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(`Expected element "${selectorText}" to contain text "${substring}", but got "${actual}"`);
+      },
+    );
+  }
+
+  async function shouldNotContainText(substring: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.contain.text', target: selector, args: [substring] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getText();
+          return !actual.includes(String(substring));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain text "${substring}"`);
+      },
+    );
+  }
+
+  async function shouldHaveClass(className: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'have.class', target: selector, args: [className] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => driver().hasClass(selector, className, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" to have class "${className}"`);
+      },
+    );
+  }
+
+  async function shouldNotHaveClass(className: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.have.class', target: selector, args: [className] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !(await driver().hasClass(selector, className, index)),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to have class "${className}"`);
+      },
+    );
+  }
+
+  async function shouldHaveAttribute(name: string, value?: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'have.attr', target: selector, args: value !== undefined ? [name, value] : [name] },
+      async () => {
+        let actual: string | null = null;
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getAttribute(name);
+          if (value !== undefined) return actual === String(value);
+          return actual !== null;
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (value !== undefined)
+            throw new Error(
+              `Expected element "${selectorText}" to have attribute "${name}" = "${value}", but got "${actual}"`,
+            );
+          throw new Error(`Expected element "${selectorText}" to have attribute "${name}"`);
+        }
+      },
+    );
+  }
+
+  async function shouldNotHaveAttribute(name: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.have.attr', target: selector, args: [name] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getAttribute(name);
+          return actual === null;
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to have attribute "${name}"`);
+      },
+    );
+  }
+
+  async function shouldHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'have.css', target: selector, args: [property, value] },
+      async () => {
+        const norm = (v: any) =>
+          String(v ?? '')
+            .replace(/\s+/g, '')
+            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
+            .toLowerCase();
+        let actualCss = '';
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          actualCss = css.value;
+          return norm(actualCss) === norm(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(
+            `Expected element "${selectorText}" to have CSS "${property}" = "${value}", but got "${actualCss}"`,
+          );
+      },
+    );
+  }
+
+  async function shouldNotHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      'assertion',
+      { type: 'assertion', key: 'not.have.css', target: selector, args: [property, value] },
+      async () => {
+        const norm = (v: any) =>
+          String(v ?? '')
+            .replace(/\s+/g, '')
+            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
+            .toLowerCase();
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          return norm(css.value) !== norm(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText}" not to have CSS "${property}" = "${value}"`);
+      },
+    );
+  }
+
+  return {
+    shouldBeVisible,
+    shouldNotBeVisible,
+    shouldExist,
+    shouldNotExist,
+    shouldBeEnabled,
+    shouldBeDisabled,
+    shouldBeClickable,
+    shouldNotBeClickable,
+    shouldBeChecked,
+    shouldNotBeChecked,
+    shouldBeFocused,
+    shouldNotBeFocused,
+    shouldHaveValue,
+    shouldNotHaveValue,
+    shouldContainValue,
+    shouldNotContainValue,
+    shouldHaveText,
+    shouldNotHaveText,
+    shouldContainText,
+    shouldNotContainText,
+    shouldHaveClass,
+    shouldNotHaveClass,
+    shouldHaveAttribute,
+    shouldNotHaveAttribute,
+    shouldHaveCss,
+    shouldNotHaveCss,
+  };
+}
+
+globalThis.__TS_RUNTIME__.createElementAssertions = createElementAssertions;