@delacour/warden-e2e 0.7.0 → 0.9.0

package/types/e2e/src/driver/ios/ios-audit.d.ts

@@ -0,0 +1,36 @@
+import type { Exec } from "../../../../core/src/exec";
+import type { RunnerSourceFiles } from "../../../../core/src/ios-runner/runner-build.types";
+import { type AsyncResult } from "../../../../types/src/result";
+import type { Logger } from "../driver.types";
+import type { NativeAuditOptions, NativeAuditResult } from "../native-audit";
+import { type SimRunnerDeps } from "./sim-runner";
+/**
+ * The iOS Simulator's XCUITest accessibility audit: the runner build (cached, unsigned), the runner process and the
+ * `audit` op behind `AuditsNatively`. Without runner sources the audit is skipped with the reason.
+ */
+export type IosNativeAudit = {
+    audit(options: NativeAuditOptions): Promise<NativeAuditResult>;
+    close(): Promise<void>;
+};
+export type IosNativeAuditOptions = {
+    udid: string;
+    exec: Exec;
+    /** the app the audit checks when the caller names none */
+    bundleId: () => string | undefined;
+    env?: Record<string, string | undefined>;
+    wardenHome?: string;
+    version?: string;
+    log?: Logger;
+    /** the runner's Xcode project as text files; default: this checkout's `packages/e2e/native` when running from source */
+    runnerSources?: () => AsyncResult<RunnerSourceFiles>;
+    /** test seams */
+    ensureBuild?: SimRunnerDeps["ensureBuild"];
+    spawn?: SimRunnerDeps["spawn"];
+    connect?: SimRunnerDeps["connect"];
+};
+/**
+ * `packages/e2e/native` of the checkout this file runs from; in a bundled install (no checkout beside it) the blob
+ * embedded in the compiled `warden` binary, which a spec process (the same binary) sees too.
+ */
+export declare function checkoutRunnerSources(importDir?: string, embedded?: () => AsyncResult<RunnerSourceFiles>): AsyncResult<RunnerSourceFiles>;
+export declare function createIosNativeAudit(o: IosNativeAuditOptions): IosNativeAudit;

package/types/e2e/src/driver/ios/ios-driver.d.ts

@@ -1,11 +1,16 @@
 import type { Exec } from "../../../../core/src/exec";
 import type { E2eEnv } from "../../env";
+import type { ReadsA11yEvents } from "../a11y-events";
+import type { ReadsA11y } from "../a11y-read";
 import type { ProbesFrontmost, ReadsAlertOn } from "../alerts";
 import type { ClockRecorder } from "../clock-recorder";
 import type { Driver, DriverResult, KeyName, Logger } from "../driver.types";
+import type { AuditsNatively } from "../native-audit";
 import type { NetworkProxyPort } from "../network-proxy";
 import type { PastesText, SelectsAll } from "../typing";
 import { type InjectFs } from "./inject";
+import { type IosA11y } from "./ios-a11y";
+import { type IosNativeAudit, type IosNativeAuditOptions } from "./ios-audit";
 import { type IosNetwork } from "./ios-network";
 import { type SwappableClient } from "./ios-session";
 import { type IosSettings, type StagedSettings } from "./ios-settings";
@@ -21,7 +26,7 @@ import type { SimdSpawn } from "./simd-transport";
  */
 export type IosDriverEnv = Pick<E2eEnv, "simd" | "simdSocket" | "helperDir">;
 /** The iOS driver is a `Driver` plus the optional capabilities of `driver/alerts.ts`. */
-export type IosDriver = Driver & SelectsAll & PastesText & ReadsAlertOn & ProbesFrontmost;
+export type IosDriver = Driver & SelectsAll & PastesText & ReadsAlertOn & ProbesFrontmost & ReadsA11y & ReadsA11yEvents & AuditsNatively;
 export type OpenIosDriverOptions = {
     udid: string;
     env?: IosDriverEnv;
@@ -64,8 +69,17 @@ export type OpenIosDriverOptions = {
     stagedSettings?: StagedSettings;
     /** state-file operations of the injected dylib's control channel, injected for tests */
     injectFs?: InjectFs;
+    /**
+     * Launch apps with the injected library so `readA11y` works (hint, custom actions, order). Default: `WARDEN_A11Y=1`.
+     * Off, a launch pays nothing for it.
+     */
+    a11y?: boolean;
     /** CoreSimulator devices directory for the host-side `AutomationEnabled` check (default `~/Library/Developer/CoreSimulator/Devices`) */
     devicesRoot?: string;
+    /** the runner's Xcode project as text files for the XCUITest audit (default: this checkout when run from source) */
+    runnerSources?: IosNativeAuditOptions["runnerSources"];
+    /** test seams for the XCUITest audit's runner */
+    nativeAudit?: Pick<IosNativeAuditOptions, "ensureBuild" | "spawn" | "connect">;
 };
 /** USB HID keyboard-page usage ids for the keys `Driver.key` offers. */
 export declare const KEY_USAGE: Readonly<Record<KeyName, number>>;
@@ -80,7 +94,13 @@ export declare function createIosDriver(swap: SwappableClient, simctl: Simctl, o
     settings?: (ctx: {
         lastBundle: () => string | undefined;
     }) => IosSettings;
+    /** screen-reader facts from the injected dylib (`ios-a11y.ts`); absent: `readA11y` answers `E_UNSUPPORTED` */
+    a11y?: () => IosA11y;
     /** per-app network conditions (`ios-network.ts`); absent: `network` answers `E_UNSUPPORTED` */
+    /** the XCUITest audit (`ios-audit.ts`); absent: `auditNatively` skips with a reason */
+    nativeAudit?: (ctx: {
+        lastBundle: () => string | undefined;
+    }) => IosNativeAudit;
     network?: (deps: {
         lastBundle: () => string | undefined;
         relaunch: (bundleId: string) => DriverResult<void>;

package/types/e2e/src/driver/ios/ios-network.d.ts

@@ -1,6 +1,6 @@
-import type { ClockCondition, HostFault, NetworkCondition } from "../../../../core/src/conditions/conditions.types";
+import type { CameraCondition, ClockCondition, HostFault, NetworkCondition } from "../../../../core/src/conditions/conditions.types";
 import type { Result } from "../../../../types/src/result";
-import type { ClockState, DriverError, DriverResult, LaunchOptions, NetworkOptions, NetworkState } from "../driver.types";
+import type { CameraState, ClockState, DriverError, DriverResult, LaunchOptions, NetworkOptions, NetworkState } from "../driver.types";
 import { type NetworkProxyPort } from "../network-proxy";
 import { type InjectChannel } from "./inject";
 /**
@@ -42,5 +42,10 @@ export type IosNetwork = {
     setClockOffset(ms: number): DriverResult<void>;
     /** Mock the injected app's wall clock (`Driver.clock`). Live when the app is injected, else staged for the next launch. */
     clock(op: ClockCondition, opts?: NetworkOptions): DriverResult<ClockState>;
+    /**
+     * The simulated camera (`Driver.camera`): feeds are staged copies. Live on an app launched with the camera on
+     * (`WARDEN_CAMERA=1`), else from the next launch, which loads the dylib for it (`appliesOnLaunch`).
+     */
+    camera(op: CameraCondition | null): DriverResult<CameraState>;
 };
 export declare function createIosNetwork(deps: IosNetworkDeps): IosNetwork;

package/types/e2e/src/driver/ios/sim-runner.d.ts

@@ -0,0 +1,41 @@
+import type { Result } from "../../../../types/src/result";
+import type { DriverError, DriverResult, Logger } from "../driver.types";
+import { type ClientOptions, type RequestOptions, type SimdClient } from "./simd-client";
+import { type SimdSpawn } from "./simd-transport";
+/**
+ * `warden-runner` (the XCUITest server of `native/ios-runner`) on an iOS Simulator, for the ops XCUITest has and the
+ * simulator helper does not: today the accessibility audit (A11Y-4). Started lazily on the first request:
+ *
+ *   build (cached, no signing)  ->  `xcodebuild test-without-building -xctestrun … -destination id=<udid>
+ *   -only-testing:…/testServe`  ->  wait for `WARDEN_RUNNER_READY {json}` (the port)  ->  NDJSON over TCP on this Mac
+ *
+ * The runner outlives the request (the next audit costs the audit only, about 2 s) and is shut down by `close()`.
+ * Anything that stops it from starting is a {@link DriverError} the caller turns into a skipped audit, never a failure.
+ */
+export declare const READY_PREFIX = "WARDEN_RUNNER_READY";
+export declare const TEST_FILTER = "-only-testing:WardenRunnerUITests/RunnerTests/testServe";
+/** The port in a `WARDEN_RUNNER_READY {json}` line, or undefined for any other line. */
+export declare function parseRunnerReady(line: string): number | undefined;
+/** The argv that serves the runner on `udid`; `env` carries the `TEST_RUNNER_*` variables `xcodebuild` forwards. */
+export declare function simRunnerArgv(o: {
+    xctestrun: string;
+    udid: string;
+    idleSeconds?: number;
+}): string[];
+export type SimRunnerDeps = {
+    udid: string;
+    /** a cached simulator runner build (`ensureSimRunnerBuild`), or why there is none */
+    ensureBuild(): Promise<Result<{
+        xctestrun: string;
+    }, string>>;
+    spawn?: SimdSpawn;
+    /** connect to the runner's port (tests inject a fake) */
+    connect?: (port: number, options: ClientOptions) => Promise<Result<SimdClient, DriverError>>;
+    readyTimeoutMs?: number;
+    log?: Logger;
+};
+export type SimRunner = {
+    request(op: string, params?: Record<string, unknown>, opts?: RequestOptions): DriverResult<unknown>;
+    close(): Promise<void>;
+};
+export declare function createSimRunner(deps: SimRunnerDeps): SimRunner;

package/types/e2e/src/driver/ios/simd-transport.d.ts

@@ -38,6 +38,15 @@ export declare function stdioTransport(opts: {
     /** how long `close()` waits for the helper to exit after closing stdin before killing it */
     graceMs?: number;
 }): TransportFactory;
-export declare function socketTransport(opts: {
+/** Where a socket transport connects: the daemon's unix socket, or a TCP port on this Mac (the Simulator runner). */
+export type SocketTarget = {
     socketPath: string;
-}): TransportFactory;
+    tcp?: undefined;
+} | {
+    tcp: {
+        hostname: string;
+        port: number;
+    };
+    socketPath?: undefined;
+};
+export declare function socketTransport(opts: SocketTarget): TransportFactory;

package/types/e2e/src/driver/native-audit.d.ts

@@ -0,0 +1,26 @@
+import type { A11yIssue } from "../a11y/a11y.types";
+import type { Driver } from "./driver.types";
+/** What a platform's own audit engine found, or why it did not run (never an error: a missing engine only skips it). */
+export type NativeAuditResult = {
+    issues: A11yIssue[];
+    skipped?: {
+        source: A11yIssue["source"];
+        reason: string;
+    };
+};
+export type NativeAuditOptions = {
+    /** iOS: the app whose accessibility the XCUITest audit checks (required there; the audit needs it running) */
+    bundleId?: string;
+    /** Android: let ATF's contrast checks read a screenshot (default true) */
+    contrast?: boolean;
+};
+/**
+ * Optional capability next to the frozen `Driver` interface (pattern: `ReadsA11y` in `a11y-read.ts`): run the
+ * platform's own accessibility audit on the screen now. iOS simulator: XCUITest `performAccessibilityAudit` through
+ * the runner (`a11y/native/xcuitest.ts`). Android: the Accessibility Test Framework inside `warden-uiad`
+ * (`a11y/native/atf.ts`). Resolves with `skipped` and a reason when the engine cannot run.
+ */
+export type AuditsNatively = {
+    auditNatively(options?: NativeAuditOptions): Promise<NativeAuditResult>;
+};
+export declare function canAuditNatively(driver: Driver): driver is Driver & AuditsNatively;

package/types/e2e/src/driver/physical-conditions.d.ts

@@ -1,6 +1,6 @@
 import type { Driver } from "./driver.types";
 /** The condition and setting ops of a `Driver`: each changes the device (or an app's grants) beyond driving its UI. */
-export declare const PHYSICAL_CONDITION_OPS: readonly ["network", "networkFaults", "location", "clock", "permissions", "timezone", "locale", "a11y", "battery", "memoryWarning", "push"];
+export declare const PHYSICAL_CONDITION_OPS: readonly ["network", "networkFaults", "location", "clock", "permissions", "timezone", "locale", "a11y", "battery", "memoryWarning", "push", "camera"];
 type PhysicalConditionOps = Pick<Driver, (typeof PHYSICAL_CONDITION_OPS)[number]>;
 /**
  * The condition ops for a physical phone: all `E_UNSUPPORTED`. On a phone they would flip airplane mode (cutting

package/types/e2e/src/driver/screen-reader.d.ts

@@ -0,0 +1,26 @@
+import type { ScreenReaderState, SpokenLine } from "../a11y/a11y.types";
+import type { Driver, DriverResult, Element } from "./driver.types";
+/**
+ * Optional capability next to the frozen `Driver` interface (pattern: `ReadsA11yEvents`): drive a real screen reader
+ * the way a user's swipes and double-taps would. Only Android offers it, and only while TalkBack is on through
+ * `a11y({ screenReader: true })`; any call with TalkBack off answers `E_UNSUPPORTED`.
+ *
+ * `next` / `prev` move TalkBack's accessibility focus one step in its traversal order and answer the node that holds
+ * it afterwards (`undefined` at either end). `activate` clicks the focused node (`ACTION_CLICK` on it or its clickable
+ * ancestor). `focused` reads the node holding accessibility focus. `spoken` answers what TalkBack said since `since`
+ * (opaque cursor, as for `a11yEvents`): from its verbose log when that is on (`source: "talkback"`), else composed
+ * from the focus events by the speech model (`source: "simulated"`).
+ */
+export type SpokenRead = {
+    lines: SpokenLine[];
+    cursor: number;
+};
+export type DrivesScreenReader = {
+    screenReaderState(): DriverResult<ScreenReaderState>;
+    screenReaderNext(): DriverResult<Element | undefined>;
+    screenReaderPrev(): DriverResult<Element | undefined>;
+    screenReaderActivate(): DriverResult<void>;
+    screenReaderFocused(): DriverResult<Element | undefined>;
+    screenReaderSpoken(since?: number): DriverResult<SpokenRead>;
+};
+export declare function canDriveScreenReader(driver: Driver): driver is Driver & DrivesScreenReader;

package/types/e2e/src/env.d.ts

@@ -1,4 +1,5 @@
-import { type ConditionsConfig } from "../../core/src/conditions/conditions.config";
+import { type A11yAuditConfig } from "../../core/src/a11y/a11y.config";
+import { type CameraSuiteFeeds, type ConditionsConfig } from "../../core/src/conditions/conditions.config";
 import type { Result } from "../../types/src/result";
 /**
  * The env names `warden e2e` writes and the spec process reads (`apps/cli` imports these). `WARDEN_HEADLESS` and
@@ -13,6 +14,8 @@ export declare const ENV_NAMES: {
     readonly appPath: "WARDEN_APP_PATH";
     readonly metroUrl: "WARDEN_METRO_URL";
     readonly launchArgs: "WARDEN_LAUNCH_ARGS";
+    /** the dev client's url scheme (`exp+<slug>`): an Android launch has no args, so Metro's `--initialUrl` becomes a deep link on this scheme */
+    readonly devClientScheme: "WARDEN_DEV_CLIENT_SCHEME";
     readonly out: "WARDEN_E2E_OUT";
     readonly timeout: "WARDEN_E2E_TIMEOUT";
     readonly actionTimeout: "WARDEN_E2E_ACTION_TIMEOUT";
@@ -52,6 +55,12 @@ export declare const ENV_NAMES: {
     readonly netproxyCommand: "WARDEN_NETPROXY_COMMAND";
     /** `1` when the suite's devices are biometrics devices: the session enrolls an iOS sim again before the app is installed */
     readonly biometrics: "WARDEN_BIOMETRICS";
+    /** JSON of the suite's `a11y` (`ignore` / `minSeverity` / `rules`): the defaults `device.a11yAudit()` and `toPassA11yAudit()` use */
+    readonly a11yAudit: "WARDEN_A11Y_AUDIT";
+    /** `1`: iOS apps launch with the injected library, so hint, custom actions, reading order and announcements can be read */
+    readonly a11y: "WARDEN_A11Y";
+    /** JSON of the suite's `camera` with absolute paths (`{ back?: { path, loop }, front? }`): staged and fed before the first `app.open()` */
+    readonly cameraFeeds: "WARDEN_CAMERA_FEEDS";
 };
 export declare const DEFAULT_TIMEOUT_MS = 120000;
 export declare const DEFAULT_ACTION_TIMEOUT_MS = 30000;
@@ -64,6 +73,8 @@ export type E2eEnv = {
     bundleId: string;
     appPath?: string;
     metroUrl?: string;
+    /** `WARDEN_DEV_CLIENT_SCHEME` */
+    devClientScheme?: string;
     launchArgs: string[];
     /** where `results.jsonl` and per-attempt artifacts go (may be relative to cwd) */
     out: string;
@@ -100,6 +111,10 @@ export type E2eEnv = {
     netproxyCommand?: string[];
     /** `WARDEN_BIOMETRICS`: this is a biometrics device (profile `<p>+bio`); iOS enrollment does not survive a reboot or a spec's `unenroll` */
     biometrics?: boolean;
+    /** `WARDEN_A11Y_AUDIT`: the suite's accessibility audit settings; absent = rules all, ignore none, minSeverity `error` */
+    a11yAudit?: A11yAuditConfig;
+    /** `WARDEN_CAMERA_FEEDS`: the suite's `camera` (absolute paths), applied before the first `app.open()` */
+    cameraFeeds?: CameraSuiteFeeds;
 };
 /**
  * Reads the spec env contract. `undefined` data = not running under warden (no `WARDEN_UDID`); an

package/types/e2e/src/expect/a11y-matchers.d.ts

@@ -0,0 +1,33 @@
+import type { A11yTarget } from "../a11y/a11y-target";
+import type { DeviceA11yAuditOptions } from "../device-a11y";
+import type { TextMatch } from "../screen/text";
+import type { AssertionContext } from "./matchers";
+export type AnnouncedOptions = {
+    /** how long to wait for the announcement (default: the assertion timeout); `.not` waits this long for none */
+    timeoutMs?: number;
+    /** same as `timeoutMs`, spelled as the other matchers do */
+    timeout?: number;
+    /** cursor from `device.announcements()`: only what came after it counts (default: everything the device kept) */
+    since?: number;
+};
+export type PassA11yAuditOptions = DeviceA11yAuditOptions;
+/**
+ * The matchers of `expect(device)` / `expect(screen)`: `toPassA11yAudit` and `toHaveAnnounced`. A failure carries the
+ * issue table or the announcements seen, and the screen as text with the `--a11y` columns (`screen-at-failure.txt`).
+ */
+export declare class DeviceAssertions {
+    private readonly target;
+    private readonly context;
+    constructor(target: A11yTarget, context: AssertionContext);
+    get not(): DeviceAssertions;
+    /**
+     * The screen as it is now has no issue at `minSeverity` (default `error`) or worse, from warden's rules and the
+     * platform's own audit. Takes the options of `device.a11yAudit` (suite `a11y` config applies); runs once, so settle
+     * first. Warnings (target size, platform guidelines) are reported only with `{ minSeverity: "warning" }`.
+     */
+    toPassA11yAudit(options?: PassA11yAuditOptions): Promise<void>;
+    /** An announcement or live-region change whose text contains the string or matches the RegExp arrived (`.not`: none did within the timeout). */
+    toHaveAnnounced(expected: TextMatch, options?: AnnouncedOptions): Promise<void>;
+    private failure;
+    private run;
+}

package/types/e2e/src/expect/expect.d.ts

@@ -1,20 +1,25 @@
 import { type Expect as BunExpect, type Matchers } from "bun:test";
+import type { Device } from "../device";
 import { E2eError } from "../errors";
 import { type Locator } from "../screen/locator";
+import type { Screen } from "../screen/screen";
 import { type Session } from "../session";
+import { DeviceAssertions } from "./a11y-matchers";
 import { LocatorAssertions } from "./matchers";
 /** Receives a failure `expect.soft` kept instead of throwing. */
 export type SoftSink = (error: E2eError) => void;
 /** `expect.soft`: `expect` whose failures are kept on the running attempt, which fails once its body has settled. */
 export type SoftExpect = {
     (actual: Locator): LocatorAssertions;
+    (actual: Device | Screen): DeviceAssertions;
     <T = unknown>(actual: T, message?: string): Matchers<T>;
 };
 /**
- * The spec `expect`: `expect(locator)` gives the polling locator matchers, anything else is bun's own `expect`
+ * The spec `expect`: `expect(locator)` gives the polling locator matchers, `expect(device)` / `expect(screen)` the
+ * accessibility ones (`toPassA11yAudit`, `toHaveAnnounced`), anything else is bun's own `expect`
  * (all of its statics — `any`, `arrayContaining`, `extend`, `not`, … — are on it too).
  */
-export type E2eExpect = ((actual: Locator) => LocatorAssertions) & BunExpect & {
+export type E2eExpect = ((actual: Locator) => LocatorAssertions) & ((actual: Device | Screen) => DeviceAssertions) & BunExpect & {
     readonly soft: SoftExpect;
 };
 export type ExpectDeps = {

package/types/e2e/src/expect/matchers.d.ts

@@ -1,5 +1,6 @@
 import { E2eError } from "../errors";
 import { type Locator } from "../screen/locator";
+import type { QueryRole } from "../screen/roles";
 import { type TextMatch } from "../screen/text";
 /**
  * A negated matcher passes only after its condition held this long without a break (or the whole timeout, if shorter).
@@ -63,6 +64,19 @@ export declare class LocatorAssertions {
     toBeChecked(options?: CheckedOptions): Promise<void>;
     toBeEnabled(options?: AssertionOptions): Promise<void>;
     toBeDisabled(options?: AssertionOptions): Promise<void>;
+    /** The computed accessible name (label, else text, else merged child text) equals the string (whitespace normalised) or matches the RegExp. */
+    toHaveAccessibleName(expected: TextMatch, options?: AssertionOptions): Promise<void>;
+    /** The element's role in the `getByRole` vocabulary (`button`, `switch`, `heading`, …). */
+    toHaveRole(expected: QueryRole, options?: AssertionOptions): Promise<void>;
+    /** The accessibility hint equals the string or matches the RegExp. iOS needs the app launched with the injected library to see hints. */
+    toHaveHint(expected: TextMatch, options?: AssertionOptions): Promise<void>;
+    /**
+     * The announcement warden's speech model composes for the element ("Save, button, double tap to save") equals the
+     * string (`exact: false`: contains it, ignoring case) or matches the RegExp. Simulated: never what the real reader says.
+     */
+    toAnnounce(expected: TextMatch, options?: TextAssertionOptions): Promise<void>;
+    /** The element holds screen-reader focus (Android TalkBack's accessibility focus; iOS does not report it). */
+    toBeA11yFocused(options?: AssertionOptions): Promise<void>;
     /** Exactly `expected` current matches (zero included). */
     toHaveCount(expected: number, options?: AssertionOptions): Promise<void>;
     private assert;

package/types/e2e/src/index.d.ts

@@ -1,7 +1,11 @@
+export type { A11yAuditOptions, A11yAuditResult, A11yEvent, A11yEventKind, A11yEventSource, A11yIgnore, A11yIssue, A11yRuleId, A11ySeverity, A11ySource, Announcement, ScreenReaderState, SpokenLine, } from "./a11y/a11y.types";
 export type { OpenOptions, OpenWaitUntil } from "./app";
-export type { ClockInput, ConditionRun, DeviceClock, DeviceLocation, DeviceNetwork, DevicePermissions, Duration, FlapOptions, LocationPoint, NetworkSetOptions, NetworkStatus, RouteOptions, TimelineStepInput, } from "./conditions/device-conditions";
+export type { CameraFacingChoice, CameraSetOptions, ClockInput, ConditionRun, DeviceCamera, DeviceClock, DeviceLocation, DeviceNetwork, DevicePermissions, Duration, FlapOptions, LocationPoint, NetworkSetOptions, NetworkStatus, RouteOptions, TimelineStepInput, } from "./conditions/device-conditions";
 export type { BiometricState, DeviceBiometrics } from "./device";
+export type { A11yAnnouncement, A11yAnnouncements, A11yAnnouncementsOptions, DeviceA11y, DeviceA11yAuditOptions, DeviceScreenReader, ScreenReaderSpokenOptions, } from "./device-a11y";
+export type { A11yOp, A11yState, CameraState } from "./driver/driver.types";
 export { E2eError } from "./errors";
+export type { AnnouncedOptions, PassA11yAuditOptions } from "./expect/a11y-matchers";
 export { expect } from "./expect/expect";
 export type { PerfBreach, PerfBudgets } from "./perf/budgets";
 export type { DevicePerf } from "./perf/device-perf";

package/types/e2e/src/runner/callsite.d.ts

@@ -1,2 +1,4 @@
 /** The absolute path of the first stack frame outside the e2e runner: the spec file calling `test()`. */
-export declare function callerFile(stack?: string | undefined): string;
+export declare function callerFile(stack?: string | undefined, 
+/** more files that never count as the caller (an API that resolves paths against the spec) */
+extraOwn?: (path: string) => boolean): string;

package/types/e2e/src/screen/render.d.ts

@@ -7,6 +7,8 @@ export type RenderOptions = {
     refs: ReadonlyMap<string, string>;
     /** cap on element lines; a `… N more (use --all)` line follows when cut */
     maxLines?: number;
+    /** append the screen-reader facts of `Element.a11y` (see {@link a11yWords}) to each line */
+    a11y?: boolean;
 };
 export type RenderedSnapshot = {
     lines: string[];
@@ -19,10 +21,16 @@ export type RenderedSnapshot = {
 };
 /** `[button] "Sign in" id=sign-in-submit`: enough to tell matches apart in an error message. */
 export declare function describeEntry(entry: NodeEntry): string;
+/**
+ * The `--a11y` tail of an entry line: `hint="…"`, `actions=["…"]`, `a11y-focused`, `not-important`, `live=polite|assertive`.
+ * Only facts the backend read are printed; an element without `a11y` adds nothing.
+ */
+export declare function a11yWords(entry: NodeEntry): string[];
 /** `@e3 [button] "Sign in" id=sign-in-submit value="…" enabled hittable (24,332 345×48)`; `indent` is in levels. */
 export declare function renderEntryLine(entry: NodeEntry, options?: {
     ref?: string;
     indent?: number;
+    a11y?: boolean;
 }): string;
 /** The entries `interactiveOnly` lists: visible ones that are interactive or carry a testID. */
 export declare function isListed(entry: NodeEntry): boolean;