e2e 0.15.2 → 0.17.0

package/dist/config/load.js

@@ -165,4 +165,3 @@ export async function loadConfigModule(configPath, options = {}) {
     }
     return defaultExport;
 }
-//# sourceMappingURL=load.js.map

package/dist/config/resolve.d.ts

@@ -34,6 +34,7 @@ export interface ResolvedConfig {
     readonly assertionTimeout: number;
     readonly cleanupTimeout: number;
     readonly retries: number;
+    readonly failOnSkippedFailure: boolean;
     readonly workers: number;
     /** Host store every produced artifact is handed to; undefined keeps files local only. */
     readonly artifactStore: ArtifactStore | undefined;
@@ -130,4 +131,3 @@ export declare function resolveConfig(raw: E2EConfig, options: {
  * because the ports never enter them.
  */
 export declare function assignPorts(config: ResolvedConfig, ports: PortAssignments): ResolvedConfig;
-//# sourceMappingURL=resolve.d.ts.map

package/dist/config/resolve.js

@@ -25,6 +25,7 @@ const TOP_LEVEL_KEYS = new Set([
     'assertionTimeout',
     'cleanupTimeout',
     'retries',
+    'failOnSkippedFailure',
     'workers',
     'artifacts',
     'output',
@@ -111,6 +112,10 @@ export function resolveConfig(raw, options) {
     const workers = boundedInt(cli.workers, '--workers', 1, 1024) ??
         boundedInt(raw.workers, 'workers', 1, 1024) ??
         (ci ? 1 : Math.max(1, Math.floor(os.availableParallelism() / 2)));
+    const failOnSkippedFailure = raw.failOnSkippedFailure === undefined ? false : raw.failOnSkippedFailure;
+    if (typeof failOnSkippedFailure !== 'boolean') {
+        throw new ConfigurationError('INVALID_CONFIG', 'failOnSkippedFailure must be a boolean');
+    }
     const artifactStore = resolveArtifactStore(raw);
     const { reporters, customReporters } = resolveReporters(raw, cli);
     const projectId = resolveProjectId(raw.projectId, options.projectRoot);
@@ -134,6 +139,7 @@ export function resolveConfig(raw, options) {
         assertionTimeout,
         cleanupTimeout,
         retries,
+        failOnSkippedFailure,
         workers,
         artifactStore,
         output,
@@ -533,6 +539,8 @@ function resolveSecrets(raw, env) {
     const credentials = new Map();
     const secrets = new Map();
     const allSecrets = new Map();
+    checkEnvNameCollisions('E2E_USER', 'credentials', Object.keys(raw.credentials ?? {}));
+    checkEnvNameCollisions('E2E_SECRET', 'secrets', Object.keys(raw.secrets ?? {}));
     for (const [name, credential] of Object.entries(raw.credentials ?? {})) {
         const prefix = envName('E2E_USER', name);
         const username = env[`${prefix}_USERNAME`] ?? credential.username;
@@ -561,6 +569,29 @@ function resolveSecrets(raw, env) {
     }
     return { credentials, secrets, allSecrets };
 }
+/**
+ * Two entries of one namespace whose names map to the same override variable
+ * (`api-key` and `api_key` both read `E2E_SECRET_API_KEY`) would both take one
+ * rotated value, so the config load refuses them, whether or not the variable
+ * is set. The message names the entries and the variable, never a value.
+ */
+function checkEnvNameCollisions(prefix, namespace, names) {
+    const byEnvName = new Map();
+    for (const name of names) {
+        const variable = envName(prefix, name);
+        byEnvName.set(variable, [...(byEnvName.get(variable) ?? []), name]);
+    }
+    for (const [variable, group] of byEnvName) {
+        if (group.length < 2)
+            continue;
+        const quoted = group.map((name) => `"${name}"`);
+        const entries = `${quoted.slice(0, -1).join(', ')} and ${quoted.at(-1)}`;
+        const variables = prefix === 'E2E_USER'
+            ? `the override variables ${variable}_USERNAME and ${variable}_PASSWORD`
+            : `the override variable ${variable}`;
+        throw new ConfigurationError('INVALID_CONFIG', `${namespace} ${entries} share ${variables}, so one value set there would replace all of them; rename all but one`);
+    }
+}
 /**
  * Every secret an engine's options hold (a `secrets.get()` the config
  * evaluated before any run existed) names a configured secret, so a typo
@@ -643,9 +674,10 @@ function computeConfigDigest(raw, projectId, targets) {
     // reporter object changes nothing about what a run records, so it never
     // enters the digest either; the built-in ids digest as they always have,
     // so adding a reporter to a config leaves its cache valid.
+    // `failOnSkippedFailure` decides only the exit code, never what runs.
     // `targets` digest by declaration below and never enter the clone: an
     // engine holds `secrets.get()` handles, which refuse to serialize.
-    const { artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
+    const { failOnSkippedFailure: _failOnSkippedFailure, artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
     const sanitized = {
         ...structuredCloneJsonSafe(plain),
         ...(reporters === undefined
@@ -716,4 +748,3 @@ function structuredCloneJsonSafe(value) {
         return isModelInstance(item) ? modelIdentity(item) : item;
     }) ?? 'null');
 }
-//# sourceMappingURL=resolve.js.map

package/dist/config/secrets.d.ts

@@ -94,4 +94,3 @@ export declare function isSecretValue(value: unknown): value is string | SecretP
 export declare function secretValueProblem(value: unknown): string;
 /** `E2E_USER_ADMIN`, `E2E_SECRET_STRIPE_KEY`: the name uppercased, everything outside A-Z0-9 as `_`. */
 export declare function envName(prefix: 'E2E_USER' | 'E2E_SECRET', name: string): string;
-//# sourceMappingURL=secrets.d.ts.map

package/dist/config/secrets.js

@@ -45,4 +45,3 @@ export function secretValueProblem(value) {
 export function envName(prefix, name) {
     return `${prefix}_${name.toUpperCase().replaceAll(/[^A-Z0-9]/g, '_')}`;
 }
-//# sourceMappingURL=secrets.js.map

package/dist/config/targets.d.ts

@@ -78,4 +78,3 @@ export declare function digestTargets(targets: readonly ResolvedTarget[]): {
         capabilities: import("../engine/index.ts").EngineCapability[];
     };
 }[];
-//# sourceMappingURL=targets.d.ts.map

package/dist/config/targets.js

@@ -117,4 +117,3 @@ function resolvePlatform(target, where) {
     }
     return platform;
 }
-//# sourceMappingURL=targets.js.map

package/dist/config/validate.d.ts

@@ -11,4 +11,3 @@ export declare function describeValue(value: unknown): string;
 export declare function boundedInt(value: number | undefined, label: string, min: number, max: number): number | undefined;
 /** An absolute http(s) URL, or undefined when the value is absent. */
 export declare function httpUrl(value: string | undefined, label: string): string | undefined;
-//# sourceMappingURL=validate.d.ts.map

package/dist/config/validate.js

@@ -54,4 +54,3 @@ export function httpUrl(value, label) {
     }
     return value;
 }
-//# sourceMappingURL=validate.js.map

package/dist/engine/contract.d.ts

@@ -370,4 +370,3 @@ export declare class EngineError extends Error {
         cause?: unknown;
     });
 }
-//# sourceMappingURL=contract.d.ts.map

package/dist/engine/contract.js

@@ -165,4 +165,3 @@ export class EngineError extends Error {
         this.retryable = options.retryable;
     }
 }
-//# sourceMappingURL=contract.js.map

package/dist/engine/index.d.ts

@@ -22,7 +22,7 @@
  */
 import { engineBrand } from '../internal/brands.ts';
 export { ConfigurationError, InfrastructureError, TestError } from '../internal/errors.ts';
-export { rejectUnknownKeys } from '../internal/options.ts';
+export { rejectUnknownKeys, rejectUnknownOptions } from '../internal/options.ts';
 export { validateJsonValue, type JsonValueRules } from '../internal/json-value.ts';
 export { describePattern, matchesText, toTextPattern } from '../internal/text.ts';
 export { resolveExpression, type ResolveExpressionOptions } from './resolve.ts';
@@ -147,8 +147,8 @@ export interface EngineFixtureContext {
         /**
          * Resolves a navigation target against the base URL. Throws
          * `APP_URL_REQUIRED` when the target declares no URL and `POLICY_DENIED`
-         * for a `file:`, `data:`, or `javascript:` scheme, so a fixture never
-         * re-implements the rule the harness owns.
+         * for any scheme but `http:` and `https:` (`about:blank` aside), so a
+         * fixture never re-implements the rule the harness owns.
          */
         resolveUrl(url: string): string;
     };
@@ -711,4 +711,3 @@ export interface EngineHandle extends Engine {
     readonly capabilities: ReadonlySet<EngineCapability>;
 }
 export { defineEngine, isEngineHandle } from './manifest.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.js

@@ -24,10 +24,11 @@ import { engineBrand } from '../internal/brands.js';
 // Semantics the spec requires every engine and contributed fixture to
 // reproduce exactly, exported so an engine never carries its own copy: the
 // runner error taxonomy, text-pattern matching, locator resolution over a
-// semantic tree, URL matching, assertion polling, and the JSON-value rules
-// for data a fixture returns, and the unknown-key check config options get.
+// semantic tree, URL matching, assertion polling, option-bag validation, the
+// JSON-value rules for data a fixture returns, and the unknown-key check
+// config options get.
 export { ConfigurationError, InfrastructureError, TestError } from '../internal/errors.js';
-export { rejectUnknownKeys } from '../internal/options.js';
+export { rejectUnknownKeys, rejectUnknownOptions } from '../internal/options.js';
 export { validateJsonValue } from '../internal/json-value.js';
 export { describePattern, matchesText, toTextPattern } from '../internal/text.js';
 export { resolveExpression } from './resolve.js';
@@ -39,4 +40,3 @@ export { obj } from '../internal/objects.js';
 export { ENGINE_ERROR_CODES, ENGINE_SPI_VERSION, EngineError, KEY_MODIFIERS, KEY_NAMES, LOCATOR_ACTION_KINDS, OBSERVED_NAME_LIMIT, OBSERVED_TEXT_LIMIT, POINTER_ACTION_KINDS, RETRYABLE_ENGINE_ERROR_CODES, parseKey, } from './contract.js';
 export { isSecret } from '../secrets.js';
 export { defineEngine, isEngineHandle } from './manifest.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/manifest.d.ts

@@ -15,4 +15,3 @@ import type { Engine, EngineHandle } from './index.ts';
 export declare function defineEngine(spec: Engine): EngineHandle;
 /** True for a defineEngine-branded handle, across realms. */
 export declare function isEngineHandle(value: unknown): value is EngineHandle;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/engine/manifest.js

@@ -290,4 +290,3 @@ export function isEngineHandle(value) {
         value !== null &&
         value[engineBrand] === true);
 }
-//# sourceMappingURL=manifest.js.map

package/dist/engine/recording.d.ts

@@ -75,4 +75,3 @@ export declare function stopProviderRecording(recording: ProviderRecording, targ
  * undefined for anything else.
  */
 export declare function hostedVideoUrl(url: unknown): string | undefined;
-//# sourceMappingURL=recording.d.ts.map

package/dist/engine/recording.js

@@ -94,4 +94,3 @@ export function hostedVideoUrl(url) {
         return undefined;
     }
 }
-//# sourceMappingURL=recording.js.map

package/dist/engine/resolve.d.ts

@@ -34,4 +34,3 @@ export interface ResolveExpressionOptions {
  * `frame` is `FRAME_NOT_FOUND`: a semantic tree has no nested documents.
  */
 export declare function resolveExpression(expression: LocatorExpression, nodes: readonly SemanticNode[], options?: ResolveExpressionOptions): SemanticNode[];
-//# sourceMappingURL=resolve.d.ts.map

package/dist/engine/resolve.js

@@ -162,4 +162,3 @@ function matchesQuery(node, query) {
             return node.testId !== undefined && matchesText(node.testId, query.value);
     }
 }
-//# sourceMappingURL=resolve.js.map

package/dist/engine/session.d.ts

@@ -22,4 +22,3 @@ export interface EngineSessionOptions {
  * minted per adapter, so refs can never leak across attempts.
  */
 export declare function createEngineSession(options: EngineSessionOptions): TargetSession;
-//# sourceMappingURL=session.d.ts.map

package/dist/engine/session.js

@@ -305,4 +305,3 @@ export function createEngineSession(options) {
     };
     return session;
 }
-//# sourceMappingURL=session.js.map

package/dist/engine/surface.d.ts

@@ -121,4 +121,3 @@ export interface TargetSession {
     /** Ends the attempt's isolation within the operation's budget. Idempotent. */
     close(operation: OperationContext): Promise<void>;
 }
-//# sourceMappingURL=surface.d.ts.map

package/dist/engine/surface.js

@@ -8,4 +8,3 @@
  * Re-exports the contract vocabulary so internal modules import one path.
  */
 export { EngineError } from './contract.js';
-//# sourceMappingURL=surface.js.map

package/dist/engine/timing.d.ts

@@ -1,3 +1,2 @@
 /** Checks cancellation before dispatching a thunk, then abandons the wait on abort. */
 export declare function raceAbort<T>(work: Promise<T> | (() => Promise<T>), signal: AbortSignal, label: string): Promise<T>;
-//# sourceMappingURL=timing.d.ts.map

package/dist/engine/timing.js

@@ -5,4 +5,3 @@ import { EngineError } from './contract.js';
 export function raceAbort(work, signal, label) {
     return withAbort(work, signal, () => new EngineError('CANCELLED', `${label} cancelled`, { retryable: false }));
 }
-//# sourceMappingURL=timing.js.map

package/dist/expect/async.d.ts

@@ -2,4 +2,3 @@
 import type { LocatorInternals } from '../locator/screen.ts';
 import type { AsyncExpectation } from '../types.ts';
 export declare function createAsyncExpectation(internals: LocatorInternals): AsyncExpectation;
-//# sourceMappingURL=async.d.ts.map

package/dist/expect/async.js

@@ -1,14 +1,25 @@
 /** Runner-owned polling locator assertions. */
 import { TestError } from '../internal/errors.js';
-import { isTextMatch, normalizeText, compareText, matchesText, toTextPattern, describePattern, } from '../internal/text.js';
+import { rejectUnknownOptions } from '../internal/options.js';
+import { isTextMatch, normalizeText, compareText, toTextPattern, describePattern, withIgnoreCase, } from '../internal/text.js';
 import { isValueControl } from '../internal/roles.js';
 import { Deadline, pollCondition } from '../internal/time.js';
 import { attributeOf, denySecureRead, isNodeVisible } from '../locator/engine.js';
 import { describeExpression } from '../locator/expression.js';
 const STATE_MATCHERS = {
-    toBeEnabled: { key: 'disabled', expected: false, describeExpected: 'enabled' },
+    toBeEnabled: {
+        key: 'disabled',
+        expected: false,
+        describeExpected: 'enabled',
+        flag: { option: 'enabled', describeExpected: 'disabled' },
+    },
     toBeDisabled: { key: 'disabled', expected: true, describeExpected: 'disabled' },
-    toBeChecked: { key: 'checked', expected: true, describeExpected: 'checked' },
+    toBeChecked: {
+        key: 'checked',
+        expected: true,
+        describeExpected: 'checked',
+        flag: { option: 'checked', describeExpected: 'unchecked' },
+    },
     toBeSelected: { key: 'selected', expected: true, describeExpected: 'selected' },
     toBeExpanded: { key: 'expanded', expected: true, describeExpected: 'expanded' },
     toBeFocused: { key: 'focused', expected: true, describeExpected: 'focused' },
@@ -19,24 +30,28 @@ const TEXT_MATCHERS = {
         mode: 'equals',
         normalize: true,
         describeExpected: (pattern) => `text ${pattern}`,
+        takesIgnoreCase: true,
     },
     toContainText: {
         field: 'text',
         mode: 'contains',
         normalize: true,
         describeExpected: (pattern) => `text containing ${pattern}`,
+        takesIgnoreCase: true,
     },
     toHaveValue: {
         field: 'value',
         mode: 'equals',
         normalize: false,
         describeExpected: (pattern) => `value ${pattern}`,
+        takesIgnoreCase: false,
     },
     toHaveAccessibleName: {
         field: 'name',
         mode: 'equals',
         normalize: true,
         describeExpected: (pattern) => `accessible name ${pattern}`,
+        takesIgnoreCase: true,
     },
 };
 class AsyncExpectationImpl {
@@ -52,9 +67,28 @@ class AsyncExpectationImpl {
     get label() {
         return describeExpression(this.internals.expression);
     }
+    /** The matcher's name as its step and its errors print it: `expect.not.toBeChecked`. */
+    api(name) {
+        return `expect.${this.negated ? 'not.' : ''}${name}`;
+    }
+    /**
+     * Refuses an option `name` does not take before anything is read: a
+     * JavaScript caller's Playwright option must fail, not run as if absent.
+     * Returns the boolean `flag` option, `undefined` when absent.
+     */
+    readOptions(name, options, flag) {
+        const api = this.api(name);
+        rejectUnknownOptions(api, options, flag === undefined ? ['timeout'] : [flag, 'timeout']);
+        if (flag === undefined || options === undefined)
+            return undefined;
+        const value = Reflect.get(options, flag);
+        if (value === undefined || typeof value === 'boolean')
+            return value;
+        throw new TestError('INVALID_ARGUMENT', `${api} option ${flag} must be a boolean`);
+    }
     async poll(spec, timeout) {
         const { engine } = this.internals.context;
-        const api = `expect.${this.negated ? 'not.' : ''}${spec.name}`;
+        const api = this.api(spec.name);
         await this.internals.context.steps.run('assertion', api, this.label, async () => {
             const deadline = engine.deadline(timeout ?? engine.assertionTimeout);
             let lastSample = { count: 0, node: null, nodes: [] };
@@ -110,32 +144,48 @@ class AsyncExpectationImpl {
             const refs = await engine.resolveAll(this.internals.expression, deadline);
             return { count: refs.length, node: null, nodes: [] };
         }
-        const { node, count } = await engine.tryRead(this.internals.expression, deadline);
+        const missingFrame = spec.evaluableWithoutNode === true ? 'empty' : 'wait';
+        const { node, count } = await engine.tryRead(this.internals.expression, deadline, missingFrame);
         return { count, node, nodes: [] };
     }
-    stateMatcher(name, timeout) {
+    /** A state matcher; its Playwright flag set to `false` expects the opposite state. */
+    stateMatcher(name, options) {
         const def = STATE_MATCHERS[name];
+        const holds = this.readOptions(name, options, def.flag?.option) ?? true;
+        const expected = holds ? def.expected : !def.expected;
         return this.poll({
             name,
-            predicate: (sample) => sample.node !== null && (sample.node.states?.[def.key] === true) === def.expected,
-            describeExpected: def.describeExpected,
+            predicate: (sample) => sample.node !== null && (sample.node.states?.[def.key] === true) === expected,
+            describeExpected: holds || def.flag === undefined ? def.describeExpected : def.flag.describeExpected,
             observed: observedState,
+        }, options?.timeout);
+    }
+    /** `toBeVisible` and `toBeHidden`: not visible means hidden or absent. */
+    visibilityMatcher(name, visible, timeout) {
+        return this.poll({
+            name,
+            evaluableWithoutNode: true,
+            predicate: (sample) => isNodeVisible(sample.node) === visible,
+            describeExpected: visible ? 'visible' : 'hidden or absent',
+            observed: visible ? observedState : (sample) => (isNodeVisible(sample.node) ? 'visible' : 'hidden'),
         }, timeout);
     }
-    textMatcher(name, expected, timeout) {
-        if (isTextMatchList(expected))
-            return this.textListMatcher(name, expected, timeout);
+    textMatcher(name, expected, options) {
         const def = TEXT_MATCHERS[name];
-        const pattern = toTextPattern(expected, { exact: true });
+        const ignoreCase = this.readOptions(name, options, def.takesIgnoreCase ? 'ignoreCase' : undefined);
+        const comparison = { mode: def.mode, normalize: def.normalize, ignoreCase };
+        if (isTextMatchList(expected))
+            return this.textListMatcher(name, expected, comparison, options?.timeout);
+        const pattern = withIgnoreCase(toTextPattern(expected, { exact: true }), ignoreCase);
         return this.poll({
             name,
             readsWithheld: def.field !== 'name',
             evaluableNode: (node) => readField(def, node) !== undefined,
             predicate: (sample) => {
                 const actual = sample.node === null ? undefined : readField(def, sample.node);
-                return actual !== undefined && compareText(actual, pattern, def);
+                return actual !== undefined && compareText(actual, pattern, comparison);
             },
-            describeExpected: def.describeExpected(describePattern(pattern)),
+            describeExpected: def.describeExpected(describeText(pattern, ignoreCase)),
             observed: (sample) => {
                 if (sample.node === null)
                     return 'no node';
@@ -144,23 +194,23 @@ class AsyncExpectationImpl {
                     return `no ${def.field} (not a form control)`;
                 return `${def.field} ${printField(def, actual)}`;
             },
-        }, timeout);
+        }, options?.timeout);
     }
     /**
      * The list form. `toHaveText` needs exactly as many matches as entries,
      * each match satisfying the entry at its position; `toContainText` needs
      * each entry contained by a distinct match, in order, as Playwright's does.
      */
-    textListMatcher(name, expected, timeout) {
+    textListMatcher(name, expected, comparison, timeout) {
         const def = TEXT_MATCHERS[name];
-        const patterns = expected.map((entry) => toTextPattern(entry, { exact: true }));
+        const patterns = expected.map((entry) => withIgnoreCase(toTextPattern(entry, { exact: true }), comparison.ignoreCase));
         const printed = (node) => {
             const actual = readField(def, node);
             return actual === undefined ? `no ${def.field}` : printField(def, actual);
         };
         const satisfies = (node, pattern) => {
             const actual = readField(def, node);
-            return actual !== undefined && compareText(actual, pattern, def);
+            return actual !== undefined && compareText(actual, pattern, comparison);
         };
         const matchesList = def.mode === 'contains' ? matchesSubsequence : matchesPositionally;
         return this.poll({
@@ -168,75 +218,62 @@ class AsyncExpectationImpl {
             readsWithheld: def.field !== 'name',
             wholeSet: 'read',
             predicate: (sample) => matchesList(sample.nodes, patterns, satisfies),
-            describeExpected: def.describeExpected(`[${patterns.map(describePattern).join(', ')}]`),
+            describeExpected: def.describeExpected(`[${patterns.map((pattern) => describeText(pattern, comparison.ignoreCase)).join(', ')}]`),
             observed: (sample) => `${def.field} [${sample.nodes.map(printed).join(', ')}]`,
         }, timeout);
     }
     toBeVisible(options) {
-        return this.poll({
-            name: 'toBeVisible',
-            evaluableWithoutNode: true,
-            predicate: (sample) => isNodeVisible(sample.node),
-            describeExpected: 'visible',
-            observed: observedState,
-        }, options?.timeout);
+        const visible = this.readOptions('toBeVisible', options, 'visible') ?? true;
+        return this.visibilityMatcher('toBeVisible', visible, options?.timeout);
     }
     toBeHidden(options) {
-        return this.poll({
-            name: 'toBeHidden',
-            evaluableWithoutNode: true,
-            predicate: (sample) => !isNodeVisible(sample.node),
-            describeExpected: 'hidden or absent',
-            observed: (sample) => (isNodeVisible(sample.node) ? 'visible' : 'hidden'),
-        }, options?.timeout);
+        this.readOptions('toBeHidden', options);
+        return this.visibilityMatcher('toBeHidden', false, options?.timeout);
     }
     toBeAttached(options) {
+        const attached = this.readOptions('toBeAttached', options, 'attached') ?? true;
         return this.poll({
             name: 'toBeAttached',
             evaluableWithoutNode: true,
-            predicate: (sample) => sample.node !== null,
-            describeExpected: 'attached',
+            predicate: (sample) => (sample.node !== null) === attached,
+            describeExpected: attached ? 'attached' : 'detached',
             observed: (sample) => (sample.node === null ? 'no node' : 'attached'),
         }, options?.timeout);
     }
     toBeEnabled(options) {
-        return this.stateMatcher('toBeEnabled', options?.timeout);
+        return this.stateMatcher('toBeEnabled', options);
     }
     toBeDisabled(options) {
-        return this.stateMatcher('toBeDisabled', options?.timeout);
+        return this.stateMatcher('toBeDisabled', options);
     }
     toBeChecked(options) {
-        return this.stateMatcher('toBeChecked', options?.timeout);
+        return this.stateMatcher('toBeChecked', options);
     }
     toBeSelected(options) {
-        return this.stateMatcher('toBeSelected', options?.timeout);
+        return this.stateMatcher('toBeSelected', options);
     }
     toBeExpanded(options) {
-        return this.stateMatcher('toBeExpanded', options?.timeout);
+        return this.stateMatcher('toBeExpanded', options);
     }
     toBeFocused(options) {
-        return this.stateMatcher('toBeFocused', options?.timeout);
+        return this.stateMatcher('toBeFocused', options);
     }
     toHaveText(expected, options) {
-        return this.textMatcher('toHaveText', expected, options?.timeout);
+        return this.textMatcher('toHaveText', expected, options);
     }
     toContainText(expected, options) {
-        return this.textMatcher('toContainText', expected, options?.timeout);
+        return this.textMatcher('toContainText', expected, options);
     }
     toHaveValue(expected, options) {
-        return this.textMatcher('toHaveValue', expected, options?.timeout);
+        return this.textMatcher('toHaveValue', expected, options);
     }
     toHaveAttribute(name, valueOrOptions, options) {
-        let value;
-        let timeout;
-        if (isTextMatch(valueOrOptions)) {
-            value = valueOrOptions;
-            timeout = options?.timeout;
-        }
-        else {
-            timeout = valueOrOptions?.timeout;
-        }
-        const pattern = value === undefined ? undefined : toTextPattern(value, { exact: true });
+        const hasValue = isTextMatch(valueOrOptions);
+        // Presence reads the third argument too when the value is `undefined`, as Playwright does.
+        const bag = hasValue ? options : valueOrOptions === undefined ? options : valueOrOptions;
+        const ignoreCase = this.readOptions('toHaveAttribute', bag, hasValue ? 'ignoreCase' : undefined);
+        const pattern = hasValue ? withIgnoreCase(toTextPattern(valueOrOptions, { exact: true }), ignoreCase) : undefined;
+        const comparison = { mode: 'equals', normalize: true, ignoreCase };
         return this.poll({
             name: 'toHaveAttribute',
             readsWithheld: true,
@@ -244,11 +281,11 @@ class AsyncExpectationImpl {
                 if (sample.node === null)
                     return false;
                 const attribute = attributeOf(sample.node, name);
-                return attribute !== null && (pattern === undefined || matchesText(attribute, pattern));
+                return attribute !== null && (pattern === undefined || compareText(attribute, pattern, comparison));
             },
             describeExpected: pattern === undefined
                 ? `attribute "${name}"`
-                : `attribute "${name}" ${describePattern(pattern)}`,
+                : `attribute "${name}" ${describeText(pattern, ignoreCase)}`,
             observed: (sample) => {
                 if (sample.node === null)
                     return 'no node';
@@ -257,12 +294,13 @@ class AsyncExpectationImpl {
                     ? `attribute "${name}" absent`
                     : `attribute "${name}" ${JSON.stringify(attribute)}`;
             },
-        }, timeout);
+        }, bag?.timeout);
     }
     toHaveAccessibleName(expected, options) {
-        return this.textMatcher('toHaveAccessibleName', expected, options?.timeout);
+        return this.textMatcher('toHaveAccessibleName', expected, options);
     }
     toHaveCount(expected, options) {
+        this.readOptions('toHaveCount', options);
         return this.poll({
             name: 'toHaveCount',
             wholeSet: true,
@@ -310,6 +348,11 @@ function readField(def, node) {
         return '';
     return isValueControl(node) ? '' : undefined;
 }
+/** A pattern as a failure message prints it, marking a string compared ignoring case. */
+function describeText(pattern, ignoreCase) {
+    const described = describePattern(pattern);
+    return pattern.kind === 'string' && ignoreCase === true ? `${described} (ignoring case)` : described;
+}
 /** The field as the failure message prints it: normalized when the comparison was, so the message shows what got compared. */
 function printField(def, actual) {
     return JSON.stringify(def.normalize ? normalizeText(actual) : actual);
@@ -326,4 +369,3 @@ function observedState(sample) {
 export function createAsyncExpectation(internals) {
     return new AsyncExpectationImpl(internals, false);
 }
-//# sourceMappingURL=async.js.map

package/dist/expect/attempt.d.ts

@@ -16,4 +16,3 @@ export interface PublishedAttempt {
 export declare function publishAttempt(context: PublishedAttempt, until: AbortSignal): void;
 /** The attempt a poll runs inside, or undefined in a standalone script. */
 export declare function currentAttempt(): PublishedAttempt | undefined;
-//# sourceMappingURL=attempt.d.ts.map

package/dist/expect/attempt.js

@@ -30,4 +30,3 @@ export function publishAttempt(context, until) {
 export function currentAttempt() {
     return slot.get(globalThis);
 }
-//# sourceMappingURL=attempt.js.map

package/dist/expect/index.d.ts

@@ -7,4 +7,3 @@ import type { Expect } from '../types.ts';
  * end of the body instead of throwing it.
  */
 export declare const expect: Expect;
-//# sourceMappingURL=index.d.ts.map

package/dist/expect/index.js

@@ -43,4 +43,3 @@ export const expect = Object.assign(dispatch, {
     stringContaining: (sample) => new StringContaining(sample),
     stringMatching: (sample) => new StringMatching(sample),
 });
-//# sourceMappingURL=index.js.map