e2e 0.15.2 → 0.16.0

package/dist/telemetry/events.js

@@ -1,16 +1,18 @@
 /**
  * The events e2e sends, built from facts the CLI already holds. Every
  * property is a count, a duration, a version, or a short token. The builders
- * copy no title, file, URL, instruction, message, or stack out of the report;
- * the one look at a message, in `failure-kind.ts`, yields a token from a
- * closed list.
- * The names a project declares for its engines, platforms, and model pass
- * through when they are plain tokens, so a homegrown engine counts as itself;
- * a name shaped like a path, a URL, or a sentence folds to `other`, and an
- * error code that is not an upper-case token, the shape of every runner
- * code, folds to `OTHER`. The unit tests hold the payload to that promise.
+ * copy no title, file, URL, instruction, message, or stack out of the report,
+ * the config, or an MCP session; the one look at a message, in
+ * `failure-kind.ts`, yields a token from a closed list.
+ * The names a project declares for its engines, platforms, and model, and the
+ * name an MCP client gives itself, pass through when they are plain tokens,
+ * so a homegrown engine counts as itself; a name shaped like a path, a URL,
+ * or a sentence folds to `other`, and an error code that is not an upper-case
+ * token, the shape of every runner code, folds to `OTHER`. The unit tests
+ * hold the payload to that promise.
  */
-import { GRAMMAR_ACTION_NAMES, PROJECT_TOOL_EVENT_PREFIX } from '../agent/action-names.js';
+import { GRAMMAR_ACTION_NAMES, GRAMMAR_TOOL_NAMES, PROJECT_TOOL_EVENT_PREFIX } from '../agent/action-names.js';
+import { modelLabel } from '../config/agent.js';
 import { STEP_KINDS } from '../run/steps.js';
 import { failureKind } from './failure-kind.js';
 import { errorCodeToken, plainToken } from './token.js';
@@ -20,6 +22,8 @@ export const EVENT_CLI_SESSION = 'e2e_cli_session';
 export const EVENT_RUN_COMPLETED = 'e2e_run_completed';
 /** One per `e2e init`, however it ended: what was chosen and whether anything was written. */
 export const EVENT_INIT_COMPLETED = 'e2e_init_completed';
+/** One per `open_session` an `e2e mcp` server served, sent when the session closes or its open fails. */
+export const EVENT_MCP_SESSION = 'e2e_mcp_session';
 /** The session's error code for a flag or argument commander rejected; no runner code exists for it. */
 export const USAGE_ERROR_CODE = 'CLI_USAGE';
 const SEMVER = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u;
@@ -80,6 +84,10 @@ function engineLabel(engine) {
 function unique(values) {
     return [...new Set(values)].toSorted();
 }
+/** Counts keyed in sorted order, so equal counts serialize equally. */
+function sortedCounts(counts) {
+    return Object.fromEntries([...counts].toSorted());
+}
 /** Every scope the run recorded, across plain results and serial groups. */
 function* scopes(report) {
     for (const result of report.run.results)
@@ -117,7 +125,7 @@ function agentActions(steps) {
             counts.set(name, (counts.get(name) ?? 0) + 1);
         }
     }
-    return Object.fromEntries([...counts].toSorted());
+    return sortedCounts(counts);
 }
 /** Whether anyone priced the model calls: a gateway that did, nobody, or no calls to price. */
 function costSource(usage, modelCalls) {
@@ -129,7 +137,50 @@ function durationMs(startedAt, finishedAt) {
     const duration = Date.parse(finishedAt) - Date.parse(startedAt);
     return Number.isFinite(duration) ? Math.max(0, duration) : null;
 }
-export function runCompletedEvent(report, flags) {
+/**
+ * Which config features a run used: counts, booleans, and the runner's own
+ * option ids, never a name, a path, or a value the project wrote.
+ */
+function configFeatures(config) {
+    const agents = [...config.agents.values()];
+    return {
+        config_workers: config.workers,
+        config_retries: config.retries,
+        config_agents: config.agents.size,
+        config_custom_executor: agents.some((agent) => agent.executor !== undefined),
+        config_separate_judge: agents.some((agent) => agent.judge !== undefined && (agent.model === undefined || modelLabel(agent.judge) !== modelLabel(agent.model))),
+        config_project_tools: new Set(agents.flatMap((agent) => Object.keys(agent.tools))).size,
+        config_credentials: config.credentials.size,
+        config_secrets: config.secrets.size,
+        config_cache_mode: config.cache.mode,
+        config_cache_store: config.cache.store === undefined ? 'file' : 'custom',
+        config_cache_strict: config.cache.strict !== false,
+        config_reporters: unique(config.reporters),
+        config_custom_reporters: config.customReporters.length,
+        config_artifact_store: config.artifactStore !== undefined,
+        config_trace_modes: unique(config.targets.map((target) => target.trace.mode)),
+        config_video_modes: unique(config.targets.map((target) => target.video.mode)),
+        config_app_commands: config.targets.filter((target) => target.app.command !== undefined).length,
+        config_environments: unique(config.targets.map((target) => target.app.environment)),
+    };
+}
+const EXPLORE_STEP_STATUSES = ['passed', 'failed', 'blocked', 'exhausted'];
+const SEVERITIES = [1, 2, 3, 4, 5];
+/** What `e2e explore` was given and found, by count: never the goal, a step's charter, or a finding's words. */
+function exploreProperties(explore) {
+    return {
+        explore_ended: explore.ended,
+        explore_max_steps: explore.budgets.maxSteps,
+        explore_timeout_ms: explore.budgets.timeoutMs,
+        explore_steps: explore.steps.length,
+        ...Object.fromEntries(EXPLORE_STEP_STATUSES.map((status) => [`explore_steps_${status}`, explore.steps.filter((step) => step.status === status).length])),
+        explore_assessed: explore.summary !== undefined,
+        explore_issues: explore.findings.filter((finding) => finding.kind === 'issue').length,
+        explore_warnings: explore.findings.filter((finding) => finding.kind === 'warning').length,
+        explore_findings_by_severity: Object.fromEntries(SEVERITIES.map((severity) => [String(severity), explore.findings.filter((finding) => finding.severity === severity).length])),
+    };
+}
+export function runCompletedEvent(report, context) {
     const { run } = report;
     const recorded = [...scopes(report)];
     const steps = recorded.flatMap((scope) => scope.steps ?? []);
@@ -144,10 +195,11 @@ export function runCompletedEvent(report, flags) {
         name: EVENT_RUN_COMPLETED,
         at: run.finishedAt,
         properties: {
+            command: context.command,
             status: run.status,
             exit_code: run.exitCode,
             duration_ms: durationMs(run.startedAt, run.finishedAt),
-            flags: [...flags],
+            flags: [...context.flags],
             tests_discovered: run.summary.discovered,
             tests_selected: run.summary.selected,
             tests_executed: run.summary.executed,
@@ -180,7 +232,49 @@ export function runCompletedEvent(report, flags) {
             primary_error_code: primary === undefined ? null : errorCodeToken(primary.code),
             error_codes: unique(errors.map((error) => errorCodeToken(error.code))).slice(0, MAX_ERROR_CODES),
             error_kinds: unique(errors.flatMap(failureKind)).slice(0, MAX_ERROR_CODES),
+            // A run whose config never loaded has no features to report.
+            ...(context.config === undefined ? {} : configFeatures(context.config)),
+            ...(run.explore === undefined ? {} : exploreProperties(run.explore)),
+        },
+    };
+}
+/**
+ * The catalog tools an MCP session serves itself, by name: the grammar and
+ * the session's own (`createSessionCatalog`). A project's tools arrive
+ * counted together; any name outside this set folds to `other`.
+ */
+const SESSION_TOOLS = new Set([...GRAMMAR_TOOL_NAMES, 'locate', 'start_recording', 'stop_recording']);
+/** One MCP session: the client, the target's platform and engine, how it ended, and its calls by the runner's tool names. */
+export function mcpSessionEvent(summary, client) {
+    const calls = new Map();
+    for (const [name, count] of summary.toolCalls) {
+        const key = SESSION_TOOLS.has(name) ? name : 'other';
+        calls.set(key, (calls.get(key) ?? 0) + count);
+    }
+    if (summary.projectToolCalls > 0)
+        calls.set('tool', summary.projectToolCalls);
+    const codes = new Map();
+    for (const [code, count] of summary.errorCodes) {
+        const key = errorCodeToken(code);
+        codes.set(key, (codes.get(key) ?? 0) + count);
+    }
+    return {
+        name: EVENT_MCP_SESSION,
+        properties: {
+            client: client === undefined ? null : plainToken(client.name),
+            client_version: client === undefined ? null : plainToken(client.version),
+            outcome: summary.outcome,
+            ended_by: summary.endedBy ?? null,
+            error_code: summary.openErrorCode === undefined ? null : errorCodeToken(summary.openErrorCode),
+            platform: summary.platform === undefined ? null : plainToken(summary.platform),
+            engine: summary.engine === undefined ? null : engineLabel(summary.engine),
+            headed: summary.headed,
+            duration_ms: Math.max(0, Math.round(summary.durationMs)),
+            sessions_open: summary.concurrent,
+            calls_total: [...calls.values()].reduce((total, count) => total + count, 0),
+            calls_failed: summary.failedCalls,
+            calls: sortedCounts(calls),
+            error_codes: sortedCounts(new Map([...codes].toSorted().slice(0, MAX_ERROR_CODES))),
         },
     };
 }
-//# sourceMappingURL=events.js.map

package/dist/telemetry/failure-kind.d.ts

@@ -13,4 +13,3 @@
 import type { ReportError } from '../report/build.ts';
 /** `CODE:kind` for an error whose code only says where it surfaced; nothing for every other code. */
 export declare function failureKind(error: ReportError): string[];
-//# sourceMappingURL=failure-kind.d.ts.map

package/dist/telemetry/failure-kind.js

@@ -41,4 +41,3 @@ export function failureKind(error) {
     const kind = FAILURE_KINDS.find(([, pattern]) => pattern.test(error.message))?.[0] ?? 'other';
     return [`${error.code}:${kind}`];
 }
-//# sourceMappingURL=failure-kind.js.map

package/dist/telemetry/posthog.d.ts

@@ -30,4 +30,3 @@ export interface PostBatchOptions {
 }
 /** Sends the batch; resolves to whether PostHog accepted it. */
 export declare function postBatch(events: readonly PostHogEvent[], options: PostBatchOptions): Promise<boolean>;
-//# sourceMappingURL=posthog.d.ts.map

package/dist/telemetry/posthog.js

@@ -26,4 +26,3 @@ export async function postBatch(events, options) {
         return false;
     }
 }
-//# sourceMappingURL=posthog.js.map

package/dist/telemetry/project.d.ts

@@ -15,4 +15,3 @@
  * working directory is not a project.
  */
 export declare function anonymousProjectId(projectRoot: string, salt: string | undefined): Promise<string | undefined>;
-//# sourceMappingURL=project.d.ts.map

package/dist/telemetry/project.js

@@ -39,4 +39,3 @@ export async function anonymousProjectId(projectRoot, salt) {
         return undefined;
     return sha256Hex(`path\n${salt}\n${projectRoot}`);
 }
-//# sourceMappingURL=project.js.map

package/dist/telemetry/store.d.ts

@@ -55,4 +55,3 @@ export declare class TelemetryStore {
     markNotified(version: number, at: string): void;
     private write;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/telemetry/store.js

@@ -163,4 +163,3 @@ export class TelemetryStore {
         }
     }
 }
-//# sourceMappingURL=store.js.map

package/dist/telemetry/telemetry.d.ts

@@ -4,8 +4,10 @@
  * One instance lives for one CLI invocation. Commands hand it events; at the
  * end of the invocation `flush` sends them in a single bounded request, so a
  * command never waits on telemetry for more than the flush budget and never
- * fails because of it. Telemetry is a CLI concern only: the runner never
- * constructs this class.
+ * fails because of it. A long-lived command (`e2e mcp`) sends what it has
+ * queued as it goes with `sendQueued`, so a client that kills it loses only
+ * what was still in progress. Telemetry is a CLI concern only: the runner
+ * never constructs this class.
  *
  * Off means off at every step. `E2E_TELEMETRY_DISABLED`, `DO_NOT_TRACK`, a
  * source checkout of the repository, an `e2e telemetry disable`, or a
@@ -26,7 +28,7 @@
 import { type TelemetryEvent } from './events.ts';
 import { anonymousProjectId } from './project.ts';
 /** Bumped when what is collected changes enough that the notice must show again. */
-export declare const NOTICE_VERSION = 2;
+export declare const NOTICE_VERSION = 3;
 export type TelemetryDisabledBy = 'E2E_TELEMETRY_DISABLED' | 'DO_NOT_TRACK' | 'checkout' | 'preference' | 'store';
 export interface TelemetryOptions {
     /** The e2e version, sent with every event. */
@@ -66,6 +68,8 @@ export declare class Telemetry {
     private command;
     private failure;
     private exitCode;
+    /** Sends `sendQueued` started that have not settled; the flush waits for them. */
+    private readonly sending;
     constructor(options: TelemetryOptions);
     /** Opened on first use, so `--version` and `--help` never touch the disk; undefined when the file cannot exist. */
     private store;
@@ -117,11 +121,18 @@ export declare class Telemetry {
     /** The session event, first in the batch; absent for an invocation that never reached a command. */
     private sessionEvent;
     /**
-     * Sends everything queued in one request, or prints it under debug. One
-     * deadline covers the project lookup still running and the request; a
-     * lost batch is the accepted cost of a command that never waits on
-     * telemetry.
+     * Sends everything queued in one request, or prints it under debug, and
+     * waits for the sends `sendQueued` started. One deadline covers the
+     * project lookup still running and the request; a lost batch is the
+     * accepted cost of a command that never waits on telemetry.
      */
     flush(maxWaitMs?: number): Promise<void>;
+    /**
+     * Sends what is queued now, without the session event, which only the
+     * flush at the end can complete. For a command that runs until its client
+     * goes away; the caller need not wait, the flush does.
+     */
+    sendQueued(maxWaitMs?: number): Promise<void>;
+    /** Sends `events` in one bounded request, or prints them under debug; nothing when off. */
+    private send;
 }
-//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry/telemetry.js

@@ -4,8 +4,10 @@
  * One instance lives for one CLI invocation. Commands hand it events; at the
  * end of the invocation `flush` sends them in a single bounded request, so a
  * command never waits on telemetry for more than the flush budget and never
- * fails because of it. Telemetry is a CLI concern only: the runner never
- * constructs this class.
+ * fails because of it. A long-lived command (`e2e mcp`) sends what it has
+ * queued as it goes with `sendQueued`, so a client that kills it loses only
+ * what was still in progress. Telemetry is a CLI concern only: the runner
+ * never constructs this class.
  *
  * Off means off at every step. `E2E_TELEMETRY_DISABLED`, `DO_NOT_TRACK`, a
  * source checkout of the repository, an `e2e telemetry disable`, or a
@@ -34,13 +36,13 @@ import { postBatch } from './posthog.js';
 import { anonymousProjectId } from './project.js';
 import { preferencesPath, TelemetryStore, telemetryConfigDir } from './store.js';
 /** Bumped when what is collected changes enough that the notice must show again. */
-export const NOTICE_VERSION = 2;
+export const NOTICE_VERSION = 3;
 /** The longest a flush may hold the process; the project lookup and the request share it. */
 const DEFAULT_FLUSH_MS = 2_000;
 /** The one-time notice: what is collected, and the two ways out. */
 function noticeText() {
     return [
-        `${picocolors.bold('e2e collects anonymous usage telemetry')} to improve the framework: the command, the versions, the OS, and run counts. Never test names, app data, or credentials.`,
+        `${picocolors.bold('e2e collects anonymous usage telemetry')} to improve the framework: the command, the versions, the OS, and summaries of runs and MCP sessions. Never test names, app data, or credentials.`,
         `Opt out with ${picocolors.cyan('e2e telemetry disable')} or ${picocolors.cyan('E2E_TELEMETRY_DISABLED=1')}. What is sent: ${picocolors.underline(`${DOCS_URL}/telemetry`)}`,
         '',
         '',
@@ -74,6 +76,8 @@ export class Telemetry {
     command;
     failure;
     exitCode;
+    /** Sends `sendQueued` started that have not settled; the flush waits for them. */
+    sending = new Set();
     constructor(options) {
         this.version = options.version;
         this.env = options.env ?? process.env;
@@ -200,14 +204,28 @@ export class Telemetry {
         return [cliSessionEvent(this.command.name, this.command.flags, ended)];
     }
     /**
-     * Sends everything queued in one request, or prints it under debug. One
-     * deadline covers the project lookup still running and the request; a
-     * lost batch is the accepted cost of a command that never waits on
-     * telemetry.
+     * Sends everything queued in one request, or prints it under debug, and
+     * waits for the sends `sendQueued` started. One deadline covers the
+     * project lookup still running and the request; a lost batch is the
+     * accepted cost of a command that never waits on telemetry.
      */
     async flush(maxWaitMs = DEFAULT_FLUSH_MS) {
         const events = [...this.sessionEvent(), ...this.queue.splice(0)];
         this.command = undefined;
+        await Promise.all([this.send(events, maxWaitMs), ...this.sending]);
+    }
+    /**
+     * Sends what is queued now, without the session event, which only the
+     * flush at the end can complete. For a command that runs until its client
+     * goes away; the caller need not wait, the flush does.
+     */
+    sendQueued(maxWaitMs = DEFAULT_FLUSH_MS) {
+        const sending = this.send(this.queue.splice(0), maxWaitMs).finally(() => this.sending.delete(sending));
+        this.sending.add(sending);
+        return sending;
+    }
+    /** Sends `events` in one bounded request, or prints them under debug; nothing when off. */
+    async send(events, maxWaitMs) {
         if (events.length === 0)
             return;
         // A choice saved from another process while this command ran wins over the snapshot taken at its start.
@@ -250,4 +268,3 @@ export class Telemetry {
         await postBatch(items, { signal: deadline, fetch: this.fetchImpl });
     }
 }
-//# sourceMappingURL=telemetry.js.map

package/dist/telemetry/token.d.ts

@@ -9,4 +9,3 @@
 export declare function plainToken(value: string): string;
 /** A runner error code as it is, `OTHER` for a code shaped like a project's own. */
 export declare function errorCodeToken(code: string): string;
-//# sourceMappingURL=token.d.ts.map

package/dist/telemetry/token.js

@@ -15,4 +15,3 @@ export function plainToken(value) {
 export function errorCodeToken(code) {
     return ERROR_CODE.test(code) ? code : 'OTHER';
 }
-//# sourceMappingURL=token.js.map

package/dist/types.d.ts

@@ -585,31 +585,39 @@ export interface TestAPI<Fixtures = TestFixtures> {
     /** Registers a suite-instance teardown hook. */
     afterAll(fn: SuiteHookFn): void;
 }
+/**
+ * The locator matchers. An option a matcher does not take, or a flag that is
+ * not a boolean, is `INVALID_ARGUMENT` before the first read.
+ */
 export interface AsyncExpectation {
     /** Inverts the matcher. A negated matcher passes after 1000 ms of continuous truth. */
     readonly not: AsyncExpectation;
-    /** Waits for visibility. */
+    /** Waits for visibility; `visible: false` waits for hidden or absent state, as `toBeHidden`. */
     toBeVisible(options?: {
+        visible?: boolean;
         timeout?: number;
     }): Promise<void>;
     /** Waits for hidden or absent state. */
     toBeHidden(options?: {
         timeout?: number;
     }): Promise<void>;
-    /** Waits for one match to exist, visible or not. */
+    /** Waits for one match to exist, visible or not; `attached: false` waits for none. */
     toBeAttached(options?: {
+        attached?: boolean;
         timeout?: number;
     }): Promise<void>;
-    /** Waits for enabled state. */
+    /** Waits for enabled state; `enabled: false` waits for disabled state. */
     toBeEnabled(options?: {
+        enabled?: boolean;
         timeout?: number;
     }): Promise<void>;
     /** Waits for disabled state. */
     toBeDisabled(options?: {
         timeout?: number;
     }): Promise<void>;
-    /** Waits for checked state. */
+    /** Waits for checked state; `checked: false` waits for unchecked state. */
     toBeChecked(options?: {
+        checked?: boolean;
         timeout?: number;
     }): Promise<void>;
     /** Waits for selected state. */
@@ -625,19 +633,11 @@ export interface AsyncExpectation {
         timeout?: number;
     }): Promise<void>;
     /** Waits for exact normalized text; a list waits for exactly that many matches, each with its entry's text, in order. */
-    toHaveText(expected: TextMatch, options?: {
-        timeout?: number;
-    }): Promise<void>;
-    toHaveText(expected: readonly TextMatch[], options?: {
-        timeout?: number;
-    }): Promise<void>;
+    toHaveText(expected: TextMatch, options?: TextMatcherOptions): Promise<void>;
+    toHaveText(expected: readonly TextMatch[], options?: TextMatcherOptions): Promise<void>;
     /** Waits for contained normalized text; a list waits for each entry to be contained by a distinct match, in order, extra matches allowed. */
-    toContainText(expected: TextMatch, options?: {
-        timeout?: number;
-    }): Promise<void>;
-    toContainText(expected: readonly TextMatch[], options?: {
-        timeout?: number;
-    }): Promise<void>;
+    toContainText(expected: TextMatch, options?: TextMatcherOptions): Promise<void>;
+    toContainText(expected: readonly TextMatch[], options?: TextMatcherOptions): Promise<void>;
     /** Waits for a form control's value, compared as it is. */
     toHaveValue(expected: TextMatch, options?: {
         timeout?: number;
@@ -646,17 +646,20 @@ export interface AsyncExpectation {
     toHaveAttribute(name: string, options?: {
         timeout?: number;
     }): Promise<void>;
-    toHaveAttribute(name: string, value: TextMatch, options?: {
-        timeout?: number;
-    }): Promise<void>;
+    toHaveAttribute(name: string, value: TextMatch, options?: TextMatcherOptions): Promise<void>;
     /** Waits for an exact match count. */
     toHaveCount(expected: number, options?: {
         timeout?: number;
     }): Promise<void>;
     /** Waits for an accessible name. */
-    toHaveAccessibleName(expected: TextMatch, options?: {
-        timeout?: number;
-    }): Promise<void>;
+    toHaveAccessibleName(expected: TextMatch, options?: TextMatcherOptions): Promise<void>;
+}
+/** Options of a locator matcher that compares text. */
+export interface TextMatcherOptions {
+    /** Compares a string case-insensitively; on a RegExp, `true` adds the `i` flag and `false` removes it. */
+    ignoreCase?: boolean;
+    /** Assertion budget in milliseconds. */
+    timeout?: number;
 }
 /**
  * An object that carries its own expectation surface, so `expect(object)`
@@ -1313,4 +1316,3 @@ export interface E2EConfig {
      */
     secrets?: Readonly<Record<string, SecretConfig>>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -3,4 +3,3 @@
  * `tests/types/sdk-types.ts` pins the parts that are easy to loosen by accident.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/docs/executors.mdx

@@ -128,7 +128,7 @@ The executor receives this context:
 
 | Member | What it is |
 | --- | --- |
-| `ctx.step` | The instruction, params, and `index` in the attempt's timeline |
+| `ctx.step` | The instruction, params, and `index` in the attempt's timeline. A registered secret value the test spelled into the instruction or a param string reads `<secret:name>`; a `secrets.get()` handle is a placeholder you fill with `typeSecret` |
 | `ctx.observe({ tree, pixels })` | Redacted screen text, with an optional node tree and masked screenshot |
 | `ctx.actions` | Checked and recorded actions: `tap`, `doubleTap`, `longPress`, `secondaryTap`, `hover`, `type`, `typeSecret`, `press`, `select`, `check`, `drag`, `scrollTo`, `scrollUntil`, `upload`, `scroll`, `navigate`, `back`, and the point and keyboard verbs below |
 | `ctx.target` | The target's `name` and `platform`, and `verbs`, the actions its engine supports. Offer only these to the model. |

package/docs/migrate/playwright.mdx

@@ -171,6 +171,9 @@ what to do today.
 | `toHaveText()`, `toContainText()` | compare the rendered text, as `{ useInnerText: true }` does in Playwright | by design |
 | `toHaveValue()`, `toHaveAttribute()`, `toHaveCount()`, `toHaveAccessibleName()` | the same | same |
 | `toHaveText(['a', 'b'])`, `toContainText([...])` on several matches | the same: `toHaveText` needs the count to match, `toContainText` an ordered subsequence | same |
+| `toBeChecked({ checked: false })`, `toBeEnabled({ enabled })`, `toBeVisible({ visible })`, `toBeAttached({ attached })` | the same | same |
+| `{ ignoreCase }` on `toHaveText()`, `toContainText()`, `toHaveAccessibleName()`, `toHaveAttribute(name, value)` | the same | same |
+| `toBeChecked({ indeterminate })`, `{ useInnerText }`, `toHaveURL(url, { ignoreCase })` | not yet; `INVALID_ARGUMENT`, so the matcher never passes on its default | missing |
 | `toHaveAttribute('aria-selected', 'true')`, `'aria-expanded'` | `toBeSelected()`, `toBeExpanded()` | renamed |
 | a positive matcher on several matches | `LOCATOR_AMBIGUOUS` at once; narrow with `filter`, `first`, or `{ visible: true }` | by design |
 | `toBeAttached()` | the same; passes on a hidden match too | same |
@@ -201,7 +204,7 @@ what to do today.
 | `page.goBack()` | `app.back()`, or `browser.back()` | renamed |
 | `page.goForward()`, `page.reload()` | `browser.forward()`, `browser.reload()` | web only |
 | `page.url()`, `page.title()` | `browser.url()`, `browser.title()` | web only |
-| `page.waitForURL()` | `browser.waitForURL()`; a string or `RegExp`, no predicate function | web only |
+| `page.waitForURL()` | `browser.waitForURL()`; a string or `RegExp`, no predicate function, and `timeout` is its only option, so `waitUntil` is `INVALID_ARGUMENT` | web only |
 | `page.waitForLoadState()` | not yet; `browser.goto(url, { waitUntil })` on the navigation itself | missing |
 | `page.waitForFunction(fn)` | `expect.poll(() => browser.evaluate(fn)).toBeTruthy()` | missing |
 | `page.waitForTimeout(ms)` | a locator assertion on the state you are waiting for: `toBeVisible()` on what appears, `toBeHidden()` on what goes away | by design |

package/docs/mobile.mdx

@@ -106,6 +106,46 @@ One test launches with its own through `device.openApp`:
 await device.openApp('com.example.app', { relaunch: true, permissions: { camera: 'deny' } });
 ```
 
+### Expo development builds
+
+A development build (`expo-dev-client`) opens on the dev launcher and loads
+its JavaScript from a dev server. On an iOS simulator, launch arguments open
+the server directly and turn off the dev menu, its onboarding sheet, and its
+floating action button, so nothing covers the app. `app.command` starts the
+server for the run:
+
+```ts title="e2e.config.ts"
+import type { E2EConfig } from 'e2e';
+import { mobile } from '@e2e-dev/mobile';
+
+export default {
+  targets: [
+    {
+      engine: mobile({ platform: 'ios' }),
+      app: {
+        bundleId: 'com.example.app',
+        launchArguments: [
+          '--initialUrl', 'http://localhost:8081',
+          '-EXDevMenuShowsAtLaunch', 'NO',
+          '-EXDevMenuIsOnboardingFinished', 'YES',
+          '-EXDevMenuShowFloatingActionButton', 'NO',
+        ],
+        command: { executable: 'npx', args: ['expo', 'start', '--port', '8081'] },
+        readyUrl: 'http://localhost:8081/status',
+      },
+    },
+  ],
+} satisfies E2EConfig;
+```
+
+Start each test with `app.open()`: the warm-up in `prepare` passes no launch
+arguments, so it rests on the dev launcher. The first launch waits for the dev
+server to bundle the app; a test's first check may need a longer timeout than
+the rest. A test that relaunches with its own `launchArguments` replaces the
+target's, so it lists these again. expo-dev-launcher on Android does not read
+`--initialUrl`: open the server there with `device.openLink` and the build's
+`exp+<slug>://expo-development-client/?url=<encoded server URL>` link.
+
 ## Several devices
 
 Add a target for each platform:

package/docs/reference/cli.mdx

@@ -240,7 +240,9 @@ bunx e2e models openai    # one provider
 
 Asks the vendor which models the stored login serves and prints one line per
 model: the id `chatgpt()`, `copilot()`, or `grok()` takes, the vendor's name
-for it, and its notes (reasoning levels, vision, preview, hidden). Without a
+for it, and its notes (reasoning levels, vision, preview, hidden, and for
+Copilot `not enabled` or `no chat completions` when `copilot()` cannot call
+it). Without a
 stored login, or when the named provider has none, exits 1 with the sign-in
 command; when one of several logins fails to list, the others still print and
 the command exits 1. An unknown provider exits 2. See

package/docs/reference/engine.mdx

@@ -964,6 +964,7 @@ Use these helpers to keep behavior consistent across engines:
 | `pollCondition({ deadline, signal, negated, evaluate, onTimeout })`, `Deadline` | Assertion polling and the negation grace window |
 | `validateJsonValue(value, label, rules?)` | Checks a value is plain JSON: a top-level `undefined` passes; a non-finite number, a cycle, an object that is not a plain object or array, or a function, symbol, bigint, or `undefined` inside is `INVALID_ARGUMENT` naming `label`. A `Secret` is `POLICY_DENIED` unless `rules.onSecret` throws its own; `rules.maxDepth` caps the nesting |
 | `rejectUnknownKeys(label, value, keys, code?)` | Throws `INVALID_CONFIG` for the first own key of `value` outside `keys`, naming the nearest known key when one is a plausible typo (`web() has unknown key "viewprt"; did you mean "viewport"?`) and the known keys otherwise: the check the runner runs on its own config objects, for an engine factory's options. Pass `'INVALID_ARGUMENT'` as `code` for an object a test passes to a fixture method |
+| `rejectUnknownOptions(api, options, known, code?)` | `INVALID_ARGUMENT` (or `code`, `INVALID_LOCATOR` for a locator option) for an option key a fixture method or matcher does not take, so a JavaScript caller's unsupported option fails instead of running on the default. `options` must be a plain object or `undefined`; a class instance or array is refused, and non-enumerable own keys count as keys |
 | `obj`, `raceAbort`, `withTimeout`, `withinCleanupBudget` | See [Contributed fixtures](#contributed-fixtures) |
 | `isProviderRecording(value)` | Whether what a provider's `record` resolved to is a recording: a parseable `startedAt` and a `stop`. Check it before keeping one, so a malformed recording fails the start, named, instead of the stop |
 | `stopProviderRecording(recording, { artifactsDir, provider, leaseId, signal })` | Ends a hosted service's recording and checks it into a `VideoSegment`; see [Provider recordings](#provider-recordings) |