@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/core/src/run/frames.d.ts

@@ -0,0 +1,16 @@
+import type { Clip } from './types.js';
+export type FrameRecorderOptions = {
+    /** The image format `capture` returns (default png). */
+    extension?: 'png' | 'jpg';
+    /** Upper bound on frames per second (default 25). */
+    maxFps?: number;
+};
+/**
+ * Record a clip from any driver that can take a screenshot: capture frames back to back while the
+ * step runs, then encode them with FFmpeg as H.264 MP4 at their real timing. Drivers without a
+ * native screen recorder (Bun WebView, WebDriver) use it; it needs `ffmpeg` on the PATH and
+ * returns no clip without it.
+ */
+export declare function recordFrames(capture: () => Promise<Uint8Array>, workDirectory: string, options?: FrameRecorderOptions): Promise<{
+    stop(output: string): Promise<Clip | null>;
+}>;

package/dist/core/src/run/frames.js

@@ -0,0 +1,52 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Record a clip from any driver that can take a screenshot: capture frames back to back while the
+ * step runs, then encode them with FFmpeg as H.264 MP4 at their real timing. Drivers without a
+ * native screen recorder (Bun WebView, WebDriver) use it; it needs `ffmpeg` on the PATH and
+ * returns no clip without it.
+ */
+export async function recordFrames(capture, workDirectory, options = {}) {
+    mkdirSync(workDirectory, { recursive: true });
+    const extension = options.extension ?? 'png';
+    const gapMs = 1000 / (options.maxFps ?? 25);
+    const started = Date.now();
+    const frames = [];
+    let stopped = false;
+    const loop = (async () => {
+        while (!stopped) {
+            const at = Date.now();
+            const bytes = await capture().catch(() => null);
+            if (bytes && bytes.length) {
+                const file = `${String(frames.length).padStart(5, '0')}.${extension}`;
+                writeFileSync(path.join(workDirectory, file), bytes);
+                frames.push({ file, atMs: at - started });
+            }
+            const wait = gapMs - (Date.now() - at);
+            if (wait > 0)
+                await new Promise((r) => setTimeout(r, wait));
+        }
+    })();
+    return {
+        async stop(output) {
+            stopped = true;
+            await loop;
+            const durationMs = Date.now() - started;
+            const last = frames.at(-1);
+            if (!last)
+                return null;
+            const list = frames
+                .map((frame, i) => `file '${frame.file}'\nduration ${(((frames[i + 1]?.atMs ?? durationMs) - frame.atMs) / 1000).toFixed(3)}`)
+                .concat(`file '${last.file}'`)
+                .join('\n');
+            const listFile = path.join(workDirectory, 'frames.txt');
+            writeFileSync(listFile, `${list}\n`);
+            mkdirSync(path.dirname(output), { recursive: true });
+            const encoded = spawnSync('ffmpeg', ['-y', '-loglevel', 'error', '-f', 'concat', '-safe', '0', '-i', listFile, '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p', '-c:v', 'libx264', '-r', '30', '-movflags', '+faststart', output], { stdio: ['ignore', 'ignore', 'pipe'] });
+            if (encoded.error || encoded.status !== 0)
+                return null;
+            return { video: output, durationMs };
+        }
+    };
+}

package/dist/core/src/run/http.d.ts

@@ -0,0 +1,41 @@
+import type { Driver, Timeline } from './types.js';
+export type HttpResponse = {
+    status: number;
+    ok: boolean;
+    headers: Headers;
+    text: string;
+    json: unknown;
+};
+export type HttpRequestOptions = {
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** What the timeline says this call was for; `METHOD /path` when omitted. */
+    label?: string;
+};
+/** What every event and recogniser receives from an HTTP client: a fetch with a base URL and a cookie jar. */
+export type HttpClient = {
+    baseUrl: string;
+    /** Sent with every request; set an `authorization` header here after signing in. */
+    headers: Record<string, string>;
+    cookies: Map<string, string>;
+    request(method: string, path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+    get(path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+    post(path: string, body?: unknown, options?: HttpRequestOptions): Promise<HttpResponse>;
+    put(path: string, body?: unknown, options?: HttpRequestOptions): Promise<HttpResponse>;
+    patch(path: string, body?: unknown, options?: HttpRequestOptions): Promise<HttpResponse>;
+    delete(path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+};
+export type HttpDriverOptions = {
+    name?: string;
+    headers?: Record<string, string>;
+    /** Per request, in milliseconds (default 30 000). */
+    timeoutMs?: number;
+};
+export declare function httpClient(baseUrl: string, timeline: Timeline, options?: HttpDriverOptions): HttpClient;
+/**
+ * The fastest driver: a client of an HTTP API, with no browser or device. Use it for actors that
+ * only talk to the system (a partner webhook, an operator API, a back office job) or to drive a
+ * whole chart at the API level. Each path attempt gets a fresh cookie jar; every call is logged to
+ * the step's timeline (method, path, status; never bodies).
+ */
+export declare function httpDriver(baseUrl: string | (() => string | Promise<string>), options?: HttpDriverOptions): Driver<HttpClient>;

package/dist/core/src/run/http.js

@@ -0,0 +1,71 @@
+function parseBody(text, contentType) {
+    if (!text || !contentType || !/[/+]json\b/i.test(contentType))
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export function httpClient(baseUrl, timeline, options = {}) {
+    const source = options.name ?? 'http';
+    const client = {
+        baseUrl,
+        headers: { ...options.headers },
+        cookies: new Map(),
+        async request(method, path, { body, headers, label } = {}) {
+            const url = new URL(path, baseUrl);
+            const cookie = [...client.cookies].map(([k, v]) => `${k}=${v}`).join('; ');
+            const init = {
+                method,
+                headers: {
+                    ...client.headers,
+                    ...(body !== undefined && typeof body !== 'string' ? { 'content-type': 'application/json' } : {}),
+                    ...(cookie ? { cookie } : {}),
+                    ...headers
+                },
+                signal: AbortSignal.timeout(options.timeoutMs ?? 30_000),
+                ...(body !== undefined ? { body: typeof body === 'string' ? body : JSON.stringify(body) } : {})
+            };
+            const response = await fetch(url, init);
+            for (const line of response.headers.getSetCookie()) {
+                const [pair] = line.split(';');
+                const at = pair?.indexOf('=') ?? -1;
+                if (pair && at > 0)
+                    client.cookies.set(pair.slice(0, at).trim(), pair.slice(at + 1).trim());
+            }
+            const text = await response.text();
+            timeline.add({
+                kind: 'system',
+                label: label ?? `${method} ${url.pathname} → ${response.status}`,
+                system: { source, endpoint: `${method} ${url.pathname}`, responseStatus: response.status }
+            });
+            return { status: response.status, ok: response.ok, headers: response.headers, text, json: parseBody(text, response.headers.get('content-type')) };
+        },
+        get: (path, o) => client.request('GET', path, o),
+        post: (path, body, o) => client.request('POST', path, { ...o, body }),
+        put: (path, body, o) => client.request('PUT', path, { ...o, body }),
+        patch: (path, body, o) => client.request('PATCH', path, { ...o, body }),
+        delete: (path, o) => client.request('DELETE', path, o)
+    };
+    return client;
+}
+/**
+ * The fastest driver: a client of an HTTP API, with no browser or device. Use it for actors that
+ * only talk to the system (a partner webhook, an operator API, a back office job) or to drive a
+ * whole chart at the API level. Each path attempt gets a fresh cookie jar; every call is logged to
+ * the step's timeline (method, path, status; never bodies).
+ */
+export function httpDriver(baseUrl, options = {}) {
+    return {
+        name: options.name ?? 'http',
+        concurrency: Number.POSITIVE_INFINITY,
+        async open({ timeline }) {
+            return httpClient(typeof baseUrl === 'function' ? await baseUrl() : baseUrl, timeline, options);
+        },
+        async close() {
+            return undefined;
+        }
+    };
+}

package/dist/core/src/run/types.d.ts

@@ -0,0 +1,248 @@
+import type { CloudEvent } from '../events/cloudevents.js';
+import type { StateValue } from '../graph.js';
+import type { PlannedPath } from '../plan.js';
+export type RunMode = 'fast' | 'showcase';
+export type Status = 'passed' | 'failed' | 'flaky' | 'not-reached';
+export type EventKind = 'user' | 'system' | 'time' | 'hand-off';
+/** `client` names which client's screen it is in a multi-client run; `also` holds the other clients' screens at the same moment. */
+export type Image = {
+    png: string;
+    webp?: string;
+    client?: string;
+    also?: Image[];
+};
+export type Clip = {
+    video: string;
+    poster?: string;
+    durationMs: number;
+    client?: string;
+};
+export type TimelineEntry = {
+    atMs: number;
+    kind: 'tap' | 'type' | 'system' | 'screen' | 'toast' | 'note' | 'time' | 'notification';
+    label: string;
+    x?: number;
+    y?: number;
+    text?: string;
+    system?: {
+        source?: string;
+        endpoint?: string;
+        eventType?: string;
+        payload?: unknown;
+        responseStatus?: number;
+    };
+    /** The client that did it, in a multi-client run. */
+    client?: string;
+};
+type TimelineState = {
+    origin: number;
+    entries: TimelineEntry[];
+};
+/**
+ * What a step records while it runs: taps, typing, system calls, the screen change. `for(client)`
+ * returns a view onto the same timeline that tags every entry with that client.
+ */
+export declare class Timeline {
+    private readonly state;
+    readonly client: string | undefined;
+    constructor(state?: TimelineState, client?: string);
+    get entries(): TimelineEntry[];
+    restart(): void;
+    add(entry: Omit<TimelineEntry, 'atMs'>): void;
+    for(client: string): Timeline;
+}
+export type RecognizerResult = {
+    matched: boolean;
+    signals: {
+        signal: string;
+        expected: 'visible' | 'hidden' | string;
+        visible: boolean;
+    }[];
+};
+export type CheckResult = {
+    check: string;
+    passed: boolean;
+    expected?: string;
+    actual?: string;
+};
+/** Per-attempt tools handed to every implementation. */
+export type StepTools = {
+    timeline: Timeline;
+    mode: RunMode;
+    /** Pause for the pacing of the current mode (no-op in fast mode for the default pauses). */
+    hold(ms: number): Promise<void>;
+    /** Scratch space shared by the events of one path attempt. */
+    data: Record<string, unknown>;
+};
+/**
+ * Which client a media hook should look at, in a multi-client run: the client a state is
+ * recognised on, or the client an event is done on. Single-client drivers ignore it.
+ */
+export type Focus = {
+    client?: string;
+};
+/**
+ * A driver owns the thing under test for one path attempt: a browser context (Playwright), a
+ * device (Detox, WebDriver/Appium), a model or an API client. Only `open` and `close` are
+ * required; media hooks are used when present. `combineDrivers` runs several at once.
+ */
+export type Driver<C> = {
+    name: string;
+    open(input: {
+        path: PlannedPath;
+        attempt: number;
+        mode: RunMode;
+        directory: string;
+        timeline: Timeline;
+    }): Promise<C>;
+    close(ctx: C, input: {
+        failed: boolean;
+        traceFile: string;
+    }): Promise<{
+        trace?: string;
+        traces?: Record<string, string>;
+    } | void>;
+    /** A settled, deterministic screenshot of the current screen. */
+    screenshot?(ctx: C, file: string, focus?: Focus): Promise<Image | null>;
+    /** Start recording one transition; `stop` encodes it and returns the clip. */
+    record?(ctx: C, workDirectory: string, focus?: Focus): Promise<{
+        stop(output: string): Promise<Clip | null>;
+    }>;
+    /** Visible text of the screen, for the privacy scan (every client's screen when unfocused). */
+    text?(ctx: C, focus?: Focus): Promise<string>;
+    /** Pause between actions; drivers can show it (a touch overlay idling) or ignore it. */
+    hold?(ctx: C, ms: number, focus?: Focus): Promise<void>;
+    /** The clients of a multi-client driver, by name, with the driver each runs on. */
+    clients?: Record<string, string>;
+    /** Pacing for showcase mode, in milliseconds. */
+    pacing?: {
+        before: number;
+        after: number;
+    };
+    /**
+     * How many path attempts can have a context open at once (browser contexts are independent; a
+     * single device is not). Runs use at most this many workers; 1 when omitted.
+     */
+    concurrency?: number;
+    dispose?(): Promise<void>;
+};
+/** How one event is made to happen. Keyed by the event's exact name in the spec. */
+export type EventImplementation<C> = {
+    kind: EventKind;
+    /** The client that does it, in a multi-client run: its screen is recorded for the clip. */
+    client?: string;
+    /** A plain-language note on how the runner makes it happen (shown to developers). */
+    how: string;
+    /** Test data the event needs before the path starts (a condition modelled as an event). */
+    prepare?(ctx: C, tools: StepTools): Promise<void>;
+    run(ctx: C, tools: StepTools): Promise<void>;
+    /** Set when the event cannot be triggered reliably yet: the path stops before it. */
+    blocked?: string;
+};
+/** How one state is recognised from the outside, and what is checked there. */
+export type StateImplementation<C> = {
+    recognize(ctx: C): Promise<RecognizerResult>;
+    /** The client whose screen shows it, in a multi-client run: that screen is the screenshot. */
+    client?: string;
+    /** Shown too briefly to wait for: not seeing it is not a failure. */
+    transient?: boolean;
+    /** States the UI cannot tell apart; never reported as "looks like" each other. */
+    sameAs?: string;
+    /** Where to look when the state changes off-screen (open a tab, reload). */
+    lookIn?(ctx: C): Promise<void>;
+    /** Within-state actions after the screenshot (dismiss a success message). */
+    settle?(ctx: C): Promise<void>;
+    checks?(ctx: C): Promise<CheckResult[]>;
+};
+/**
+ * Puts the system directly in one configuration of the chart (create the data, sign in, open the
+ * screen), so paths can start there instead of walking every step before it. A seed must leave
+ * the system exactly as the steps that lead there would: then results of the stretch before it
+ * and the stretch after it compose, and Atlas checks that by recognising the state both ways.
+ */
+export type Seed<C> = {
+    /** A state name (with the default configuration inside and beside it) or a full state value. */
+    at: string | StateValue;
+    /** A plain-language note on how the seed gets there (shown to developers). */
+    how: string;
+    run(ctx: C, input: {
+        path: PlannedPath;
+        tools: StepTools;
+    }): Promise<void>;
+    /**
+     * The state the seed leaves on screen, recognised before the first step. In a parallel state
+     * it says which region the seed opens. The state `at` names (or its active leaf), or the last
+     * active leaf, when omitted.
+     */
+    shows?: string;
+    /**
+     * Events this seed exists for: a variant of a configuration (the same states, different data,
+     * such as a member at an address no lab serves). It starts only paths that take one of these
+     * events, and paths that take one start from a seed that lists it.
+     */
+    for?: string[];
+    /** Set when the configuration cannot be seeded yet: paths start from another seed. */
+    blocked?: string;
+};
+export type Implementation<C> = {
+    events: Record<string, EventImplementation<C>>;
+    states: Record<string, StateImplementation<C>>;
+    /**
+     * Named seeds: configurations paths can start from. Journeys are cut at every seeded
+     * configuration they pass through, so each stretch runs on its own and in parallel.
+     */
+    seeds?: Record<string, Seed<C>>;
+    /** Put the system in the scope's start configuration, for paths that start without a seed. */
+    setup?(ctx: C, input: {
+        path: PlannedPath;
+        tools: StepTools;
+    }): Promise<void>;
+    /** Whether `setup` can start a path in this configuration; a string is the reason it cannot. */
+    canStart?(active: string[]): true | string;
+    /**
+     * Ids that tell this attempt's business events from those of attempts running beside it (a
+     * user id, a trace id). Shared event sources keep only events and log lines that contain one.
+     */
+    correlate?(ctx: C): string[] | Promise<string[]>;
+};
+/** Where business events come from: a CloudEvents endpoint, a log, a message queue. */
+export type EventSource = {
+    name: string;
+    /** Where "now" is in the source; `collect` returns what arrived after this mark. */
+    mark(): unknown;
+    collect(mark?: unknown): Promise<{
+        events: CloudEvent[];
+        text?: string;
+    }>;
+    close?(): Promise<void>;
+};
+/** How a business event named in `meta.events` is recognised in what a source collected. */
+export type EventMatcher = {
+    type: string;
+} | {
+    pattern: RegExp;
+} | ((events: CloudEvent[], text: string) => boolean);
+export type PrivacyRules = {
+    /** Patterns that must never appear on screen or in a manifest. */
+    deny?: {
+        name: string;
+        pattern: RegExp;
+    }[];
+    /** Emails that may appear (synthetic domains, support addresses). */
+    allowEmails?: RegExp[];
+    /** Hosts the run may target; loopback only by default. */
+    allowHosts?: string[];
+};
+/**
+ * A driver for anything you can reach from Node: a domain model, an API client, a CLI. `create`
+ * returns a fresh context per path attempt; recognisers and events work on it directly.
+ */
+export declare function functionDriver<C>(create: (input: {
+    path: PlannedPath;
+    timeline: Timeline;
+}) => C | Promise<C>, options?: {
+    name?: string;
+    dispose?: (ctx: C) => void | Promise<void>;
+    concurrency?: number;
+}): Driver<C>;
+export {};

package/dist/core/src/run/types.js

@@ -0,0 +1,39 @@
+/**
+ * What a step records while it runs: taps, typing, system calls, the screen change. `for(client)`
+ * returns a view onto the same timeline that tags every entry with that client.
+ */
+export class Timeline {
+    state;
+    client;
+    constructor(state = { origin: Date.now(), entries: [] }, client) {
+        this.state = state;
+        this.client = client;
+    }
+    get entries() {
+        return this.state.entries;
+    }
+    restart() {
+        this.state.origin = Date.now();
+        this.state.entries = [];
+    }
+    add(entry) {
+        this.state.entries.push({ atMs: Date.now() - this.state.origin, ...(this.client ? { client: this.client } : {}), ...entry });
+    }
+    for(client) {
+        return new Timeline(this.state, client);
+    }
+}
+/**
+ * A driver for anything you can reach from Node: a domain model, an API client, a CLI. `create`
+ * returns a fresh context per path attempt; recognisers and events work on it directly.
+ */
+export function functionDriver(create, options = {}) {
+    return {
+        name: options.name ?? 'function',
+        concurrency: options.concurrency ?? Number.POSITIVE_INFINITY,
+        open: ({ path, timeline }) => Promise.resolve(create({ path, timeline })),
+        close: async (ctx) => {
+            await options.dispose?.(ctx);
+        }
+    };
+}

package/dist/core/src/signals.d.ts

@@ -0,0 +1,110 @@
+import type { StateImplementation } from './run/types.js';
+/**
+ * A UI signal: something visible (or not) that proves where the app is. Test IDs first, then
+ * accessible roles and names, then labels and text, as the Testing Library guidance orders them.
+ * The same values work with every driver that recognises screens by signals (Playwright, Bun
+ * WebView, WebDriver); each resolves them against its own UI tree.
+ */
+export type Signal = {
+    testId: string;
+} | {
+    role: string;
+    name?: string | RegExp;
+    exact?: boolean;
+} | {
+    text: string | RegExp;
+    exact?: boolean;
+} | {
+    label: string | RegExp;
+} | {
+    css: string;
+};
+export declare const testId: (id: string) => Signal;
+export declare const text: (value: string | RegExp, options?: {
+    exact?: boolean;
+}) => Signal;
+export declare const role: (r: string, name?: string | RegExp, options?: {
+    exact?: boolean;
+}) => Signal;
+export declare const label: (value: string | RegExp) => Signal;
+export declare const css: (selector: string) => Signal;
+export declare function describeSignal(signal: Signal): string;
+export type SignatureSpec<S = Signal> = {
+    all?: S[];
+    any?: S[];
+    none?: S[];
+};
+export type ScreenSpec<C, S = Signal> = SignatureSpec<S> & {
+    checks?: {
+        check: string;
+        signal: S;
+    }[];
+    transient?: boolean;
+    sameAs?: string;
+    lookIn?: (ctx: C) => Promise<void>;
+    settle?: (ctx: C) => Promise<void>;
+};
+/**
+ * Build `screen()` for a driver from one question: is this signal visible right now? A state is
+ * recognised when every `all` is visible, one `any` is visible and no `none` is. Drivers with
+ * their own locators (WebDriver's) pass their signal type and how to describe it.
+ */
+export declare function signatureScreen<C, S = Signal>(isVisible: (ctx: C, signal: S) => Promise<boolean>, describe: (signal: S) => string): (spec: ScreenSpec<C, S>) => StateImplementation<C>;
+/**
+ * The driver-neutral surface of a screen: Playwright, Bun WebView and WebDriver (web and native)
+ * contexts all provide it, so an implementation written against it runs on any of them, and the
+ * clients of one run can use different drivers.
+ */
+export type SignalContext = {
+    /** Open a URL (a path resolves against the driver's base URL; a deep link in a native app). */
+    goto(url: string): Promise<void>;
+    isVisible(signal: Signal): Promise<boolean>;
+    user: {
+        tap(target: Signal, label: string): Promise<void>;
+        type(target: Signal, text: string, label: string): Promise<void>;
+    };
+};
+/** A state recognised from signals on any driver that provides a `SignalContext`. */
+export declare const screen: (spec: ScreenSpec<SignalContext, Signal>) => StateImplementation<SignalContext>;
+type WireMatch = {
+    text: string;
+    exact: boolean;
+} | {
+    regex: string;
+    flags: string;
+};
+export type WireSignal = {
+    kind: 'css';
+    selector: string;
+} | {
+    kind: 'testId';
+    id: string;
+} | {
+    kind: 'role';
+    role: string;
+    name: WireMatch | null;
+} | {
+    kind: 'label';
+    match: WireMatch;
+} | {
+    kind: 'text';
+    match: WireMatch;
+};
+/** A signal as JSON, for a probe that runs inside the page. */
+export declare function toWire(signal: Signal): WireSignal;
+/** Where a probe found a signal: whether it is visible, and the centre of the first visible match in CSS pixels. */
+export type DomProbeResult = {
+    visible: boolean;
+    count: number;
+    x?: number;
+    y?: number;
+};
+/**
+ * A function expression, as source, that finds a wire signal in a DOM: `(signal, scroll,
+ * withElement) => DomProbeResult`, plus the element itself when `withElement` is set (WebDriver
+ * returns it as an element reference). It is plain JavaScript so any driver can run it in a page (Bun WebView's
+ * `evaluate`, WebDriver's Execute Script). Roles follow the HTML-AAM implicit role mapping for the
+ * common elements; names follow aria-label, the associated label, then text content.
+ */
+export declare const DOM_PROBE = "(signal, scroll, withElement) => {\n  const norm = (s) => String(s || '').replace(/\\s+/g, ' ').trim();\n  const matches = (value, m) => (m.regex !== undefined ? new RegExp(m.regex, m.flags).test(value) : m.exact ? value === m.text : value.toLowerCase().includes(m.text.toLowerCase()));\n  const shown = (el) => {\n    const r = el.getBoundingClientRect();\n    const st = getComputedStyle(el);\n    return r.width > 0 && r.height > 0 && st.visibility !== 'hidden' && st.display !== 'none' && Number(st.opacity) !== 0;\n  };\n  const ROLES = {\n    button: 'button,[role=button],input[type=button],input[type=submit],input[type=reset]',\n    heading: 'h1,h2,h3,h4,h5,h6,[role=heading]',\n    link: 'a[href],[role=link]',\n    textbox: 'input:not([type]),input[type=text],input[type=email],input[type=tel],input[type=url],input[type=search],input[type=password],textarea,[role=textbox]',\n    checkbox: 'input[type=checkbox],[role=checkbox]',\n    radio: 'input[type=radio],[role=radio]',\n    combobox: 'select,[role=combobox]',\n    listitem: 'li,[role=listitem]',\n    list: 'ul,ol,[role=list]',\n    status: 'output,[role=status]',\n    alert: '[role=alert]',\n    dialog: 'dialog,[role=dialog]',\n    img: 'img[alt],[role=img]'\n  };\n  const labelOf = (el) => norm(el.getAttribute('aria-label') || (el.labels && el.labels[0] ? el.labels[0].textContent : ''));\n  const nameOf = (el) => labelOf(el) || norm(el.textContent) || norm(el.getAttribute('alt') || el.getAttribute('title') || el.getAttribute('placeholder') || (el.type === 'submit' || el.type === 'button' ? el.value : ''));\n  const ownText = (el) => Array.from(el.childNodes).some((n) => n.nodeType === 3 && n.textContent.trim());\n  let found = [];\n  if (signal.kind === 'css') found = Array.from(document.querySelectorAll(signal.selector));\n  else if (signal.kind === 'testId') found = Array.from(document.querySelectorAll('[data-testid=\"' + CSS.escape(signal.id) + '\"]'));\n  else if (signal.kind === 'role') found = Array.from(document.querySelectorAll(ROLES[signal.role] || '[role=\"' + signal.role + '\"]')).filter((el) => !signal.name || matches(nameOf(el), signal.name));\n  else if (signal.kind === 'label') found = Array.from(document.querySelectorAll('input,textarea,select,[aria-label]')).filter((el) => matches(labelOf(el), signal.match));\n  else found = Array.from(document.querySelectorAll('body *')).filter((el) => ownText(el) && matches(norm(el.textContent), signal.match));\n  const el = found.find(shown);\n  if (!el) return { visible: false, count: found.length };\n  if (scroll) el.scrollIntoView({ block: 'center', inline: 'center' });\n  const r = el.getBoundingClientRect();\n  const at = { visible: true, count: found.length, x: r.x + r.width / 2, y: r.y + r.height / 2 };\n  return withElement ? Object.assign(at, { element: el }) : at;\n}";
+export {};