@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/schema/src/spec.d.ts

@@ -0,0 +1,245 @@
+import { z } from 'zod/v4';
+export declare const SPEC_SCHEMA_VERSION = 1;
+export declare const DesignLinkSchema: z.ZodObject<{
+    image: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DesignLink = z.infer<typeof DesignLinkSchema>;
+export declare const ContractStepSchema: z.ZodObject<{
+    keyword: z.ZodString;
+    text: z.ZodString;
+    table: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+    docString: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const BusinessContractSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    source: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        keyword: z.ZodString;
+        text: z.ZodString;
+        table: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+        docString: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BusinessContract = z.infer<typeof BusinessContractSchema>;
+/**
+ * Every field a state's `meta` may carry. Each one is optional on its own: the visualizer keeps
+ * the fields that parse and reports the ones that don't.
+ */
+export declare const StateMetaShape: {
+    readonly description: z.ZodString;
+    readonly snapshot: z.ZodString;
+    readonly events: z.ZodArray<z.ZodString>;
+    readonly confidence: z.ZodEnum<{
+        confirmed: "confirmed";
+        assumed: "assumed";
+    }>;
+    readonly source: z.ZodArray<z.ZodString>;
+    readonly checks: z.ZodArray<z.ZodString>;
+    readonly childMachine: z.ZodString;
+    readonly childFinalEvents: z.ZodRecord<z.ZodString, z.ZodString>;
+    readonly deadEnd: z.ZodString;
+    readonly owner: z.ZodString;
+    readonly tier: z.ZodString;
+    readonly quint: z.ZodString;
+    readonly gherkin: z.ZodArray<z.ZodString>;
+    readonly contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            keyword: z.ZodString;
+            text: z.ZodString;
+            table: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            docString: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    readonly design: z.ZodObject<{
+        image: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly hints: z.ZodArray<z.ZodString>;
+    readonly eventKinds: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        time: "time";
+        user: "user";
+        system: "system";
+        "hand-off": "hand-off";
+    }>>>;
+    readonly timeEvents: z.ZodRecord<z.ZodString, z.ZodString>;
+};
+export declare const StateMetaSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    snapshot: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        assumed: "assumed";
+    }>>;
+    source: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    checks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    childMachine: z.ZodOptional<z.ZodString>;
+    childFinalEvents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    deadEnd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+    quint: z.ZodOptional<z.ZodString>;
+    gherkin: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    contracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            keyword: z.ZodString;
+            text: z.ZodString;
+            table: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            docString: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    design: z.ZodOptional<z.ZodObject<{
+        image: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventKinds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        time: "time";
+        user: "user";
+        system: "system";
+        "hand-off": "hand-off";
+    }>>>>;
+    timeEvents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type StateMeta = z.infer<typeof StateMetaSchema>;
+export declare const TransitionTargetSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    target: z.ZodString;
+}, z.core.$strip>]>;
+export declare const STATE_TYPES: readonly ["atomic", "compound", "parallel", "final"];
+export type StateType = (typeof STATE_TYPES)[number];
+export type StateNodeConfig = {
+    id?: string | undefined;
+    initial?: string | undefined;
+    type?: 'parallel' | 'final' | undefined;
+    meta?: StateMeta | undefined;
+    states?: Record<string, StateNodeConfig> | undefined;
+    on?: Record<string, z.infer<typeof TransitionTargetSchema>> | undefined;
+};
+export declare const StateNodeSchema: z.ZodType<StateNodeConfig>;
+export declare const MachineSchema: z.ZodObject<{
+    id: z.ZodString;
+    initial: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        parallel: "parallel";
+    }>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            confirmed: "confirmed";
+            assumed: "assumed";
+        }>>;
+        source: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        checks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        childMachine: z.ZodOptional<z.ZodString>;
+        childFinalEvents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        deadEnd: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        quint: z.ZodOptional<z.ZodString>;
+        gherkin: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            source: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            steps: z.ZodArray<z.ZodObject<{
+                keyword: z.ZodString;
+                text: z.ZodString;
+                table: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                docString: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        design: z.ZodOptional<z.ZodObject<{
+            image: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        eventKinds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+            time: "time";
+            user: "user";
+            system: "system";
+            "hand-off": "hand-off";
+        }>>>>;
+        timeEvents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    states: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const JourneySchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    events: z.ZodArray<z.ZodString>;
+    endsIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    owner: z.ZodOptional<z.ZodString>;
+    tour: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type JourneyConfig = z.infer<typeof JourneySchema>;
+export declare const JourneysFileSchema: z.ZodObject<{
+    journeys: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const AtlasContextSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    directories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const AtlasHandOffSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    event: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `atlas.yaml` at the specs root: the product map. Optional; without it every directory holding a
+ * chart becomes a context named after its first path segment.
+ */
+export declare const AtlasFileSchema: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    contexts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    handOffs: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    excluded: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** `<chart>.layout.json` beside a chart: a hand-tuned layout the visualizer respects. */
+export declare const LayoutFileSchema: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodLiteral<1>>;
+    positions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    sizes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LayoutFile = z.infer<typeof LayoutFileSchema>;
+/**
+ * `specs/index.json`: the statechart files under the specs root, so a static host can serve the
+ * spec without directory listings. `ref` names the branch or commit the files came from.
+ */
+export declare const SpecIndexSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    generatedAt: z.ZodString;
+    ref: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    files: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SpecIndex = z.infer<typeof SpecIndexSchema>;
+export declare const STATECHART_FILE_PATTERNS: RegExp[];
+export declare function isStatechartFile(path: string): boolean;

package/dist/schema/src/spec.js

@@ -0,0 +1,133 @@
+import { z } from 'zod/v4';
+import { ConfidenceSchema, EventKindSchema } from './common.js';
+export const SPEC_SCHEMA_VERSION = 1;
+export const DesignLinkSchema = z.object({
+    image: z.string().min(1).describe('URL or spec-relative path of a design frame'),
+    url: z.string().optional().describe('Where the design lives, for example a Figma frame link'),
+    label: z.string().optional()
+});
+export const ContractStepSchema = z.object({
+    keyword: z.string().min(1),
+    text: z.string(),
+    table: z.array(z.array(z.string())).optional(),
+    docString: z.string().optional()
+});
+export const BusinessContractSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    source: z.string().min(1),
+    description: z.string().optional(),
+    steps: z.array(ContractStepSchema)
+});
+/**
+ * Every field a state's `meta` may carry. Each one is optional on its own: the visualizer keeps
+ * the fields that parse and reports the ones that don't.
+ */
+export const StateMetaShape = {
+    description: z.string(),
+    snapshot: z.string(),
+    events: z.array(z.string()).describe('Business events that happen on entering the state'),
+    confidence: ConfidenceSchema,
+    source: z.array(z.string()),
+    checks: z.array(z.string()),
+    childMachine: z.string(),
+    childFinalEvents: z.record(z.string(), z.string()),
+    deadEnd: z.string(),
+    owner: z.string(),
+    tier: z.string(),
+    quint: z.string().describe('Quint model reference'),
+    gherkin: z.array(z.string()).describe('Feature files or scenarios that cover the state'),
+    contracts: z.array(BusinessContractSchema).describe('Business rules and their exact Given/When/Then examples, copied from the authoritative source'),
+    design: DesignLinkSchema,
+    hints: z.array(z.string()).describe('What the screen shows, for the placeholder sketch'),
+    eventKinds: z
+        .record(z.string(), EventKindSchema)
+        .describe('Chart-level: who or what sends each event; overrides the runner and the guess'),
+    timeEvents: z
+        .record(z.string(), z.string())
+        .describe('Chart-level: time events and the span each one jumps, for example "5 minutes"')
+};
+export const StateMetaSchema = z.object(StateMetaShape).partial();
+export const TransitionTargetSchema = z.union([
+    z.string().min(1),
+    z.object({ target: z.string().min(1) })
+]);
+export const STATE_TYPES = ['atomic', 'compound', 'parallel', 'final'];
+export const StateNodeSchema = z.lazy(() => z.object({
+    id: z.string().optional(),
+    initial: z.string().optional(),
+    type: z.enum(['parallel', 'final']).optional(),
+    meta: StateMetaSchema.optional(),
+    states: z.record(z.string(), StateNodeSchema).optional(),
+    on: z.record(z.string(), TransitionTargetSchema).optional()
+}));
+export const MachineSchema = z.object({
+    id: z.string().min(1),
+    initial: z.string().optional(),
+    type: z.enum(['parallel']).optional(),
+    meta: StateMetaSchema.optional(),
+    states: z.record(z.string(), z.unknown())
+});
+export const JourneySchema = z.object({
+    description: z.string().optional(),
+    events: z.array(z.string()),
+    endsIn: z.array(z.string()).optional(),
+    owner: z.string().optional(),
+    tour: z.boolean().optional().describe('Include in the guided tour')
+});
+export const JourneysFileSchema = z.object({
+    journeys: z.record(z.string(), z.unknown())
+});
+export const AtlasContextSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    owner: z.string().optional(),
+    directories: z.array(z.string()).optional().describe('Spec-relative directories holding its charts')
+});
+export const AtlasHandOffSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    event: z.string().min(1),
+    description: z.string().optional()
+});
+/**
+ * `atlas.yaml` at the specs root: the product map. Optional; without it every directory holding a
+ * chart becomes a context named after its first path segment.
+ */
+export const AtlasFileSchema = z.object({
+    schemaVersion: z.number().int().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    contexts: z.array(z.unknown()).optional(),
+    handOffs: z.array(z.unknown()).optional(),
+    excluded: z.array(z.string()).optional()
+});
+/** `<chart>.layout.json` beside a chart: a hand-tuned layout the visualizer respects. */
+export const LayoutFileSchema = z.object({
+    schemaVersion: z.literal(1).optional(),
+    positions: z.record(z.string(), z.object({ x: z.number(), y: z.number() })),
+    sizes: z.record(z.string(), z.object({ width: z.number(), height: z.number() })).optional()
+});
+/**
+ * `specs/index.json`: the statechart files under the specs root, so a static host can serve the
+ * spec without directory listings. `ref` names the branch or commit the files came from.
+ */
+export const SpecIndexSchema = z.object({
+    schemaVersion: z.literal(1),
+    generatedAt: z.string(),
+    ref: z.string().nullable().optional(),
+    files: z.array(z.string())
+});
+export const STATECHART_FILE_PATTERNS = [
+    /(^|\/)atlas\.ya?ml$/,
+    /(^|\/)([\w.-]+\.)?machine\.(ya?ml|json)$/,
+    /(^|\/)[\w.-]+\.scxml$/,
+    /(^|\/)journeys\.ya?ml$/,
+    /(^|\/)known-issues\.md$/,
+    /(^|\/)open-questions\.md$/,
+    /(^|\/)[\w.-]+\.layout\.json$/
+];
+export function isStatechartFile(path) {
+    return STATECHART_FILE_PATTERNS.some((pattern) => pattern.test(path));
+}

package/dist/vitest/src/index.d.ts

@@ -0,0 +1,22 @@
+import type { AtlasConfig, RunCommandOptions } from '../../core/src/index.js';
+type Suite = {
+    describe: (name: string, fn: () => void) => void;
+    it: (name: string, fn: () => void | Promise<void>, timeout?: number) => void;
+    beforeAll: (fn: () => Promise<void>, timeout?: number) => void;
+    expect: (value: unknown) => {
+        toBe(expected: unknown): void;
+    };
+};
+/**
+ * Turn an Atlas config into a test suite: one test per planned path, so any Vitest/Jest-style
+ * runner reports each journey and generated path on its own. The whole plan runs once in
+ * `beforeAll` (paths share one manifest); each test then reads its path's outcome.
+ *
+ *   import { describe, it, beforeAll, expect } from 'bun:test';
+ *   describeAtlas(config, { describe, it, beforeAll, expect });
+ */
+export declare function describeAtlas<C>(config: AtlasConfig<C>, suite: Suite, options?: RunCommandOptions & {
+    baseDirectory?: string;
+    timeoutMs?: number;
+}): void;
+export { functionDriver } from '../../core/src/index.js';

package/dist/vitest/src/index.js

@@ -0,0 +1,33 @@
+import { prepare, runConfig } from '../../core/src/index.js';
+/**
+ * Turn an Atlas config into a test suite: one test per planned path, so any Vitest/Jest-style
+ * runner reports each journey and generated path on its own. The whole plan runs once in
+ * `beforeAll` (paths share one manifest); each test then reads its path's outcome.
+ *
+ *   import { describe, it, beforeAll, expect } from 'bun:test';
+ *   describeAtlas(config, { describe, it, beforeAll, expect });
+ */
+export function describeAtlas(config, suite, options = {}) {
+    const prepared = prepare(config, options.baseDirectory);
+    const timeout = options.timeoutMs ?? 30 * 60_000;
+    suite.describe(`atlas: ${prepared.scope.chart}`, () => {
+        let outcome = null;
+        suite.beforeAll(async () => {
+            outcome = await runConfig(config, { ...options, log: options.log ?? (() => undefined) }, options.baseDirectory);
+        }, timeout);
+        suite.it('is a pure, reachable statechart whose journeys replay', () => {
+            const structural = prepared.lint.findings.filter((f) => f.rule !== 'implemented').map((f) => f.message);
+            suite.expect(structural.join('\n')).toBe('');
+        });
+        for (const planned of prepared.plan.paths) {
+            suite.it(`${planned.kind}: ${planned.name}`, () => {
+                const result = outcome?.manifest.paths.find((p) => p.id === planned.id);
+                if (!result || result.status === 'not-reached')
+                    return;
+                const error = result.attempts.at(-1)?.error ?? '';
+                suite.expect(result.status === 'failed' ? error : 'ok').toBe('ok');
+            });
+        }
+    });
+}
+export { functionDriver } from '../../core/src/index.js';

package/dist/webdriver/src/driver.d.ts

@@ -0,0 +1,69 @@
+import type { Driver } from '../../core/src/index.js';
+import type { Signal, SignalContext } from '../../core/src/signals.js';
+import type { Locator } from './protocol.js';
+import { WebDriverSession } from './protocol.js';
+/** What a step points at: a signal (resolved per platform) or a raw WebDriver locator. */
+export type Target = Signal | Locator;
+export type Mode = 'web' | 'native';
+/** What every event and recogniser receives: the session and user actions logged to the timeline. */
+export type WebDriverContext = SignalContext & {
+    session: WebDriverSession;
+    mode: Mode;
+    baseUrl: string | undefined;
+    /** Navigate, relative to `baseUrl` (a deep link in a native session). */
+    goto(url: string): Promise<void>;
+    /** The first visible element a target resolves to, or null. */
+    find(target: Target): Promise<string | null>;
+    isVisible(target: Target): Promise<boolean>;
+    user: {
+        tap(target: Target, label: string): Promise<void>;
+        type(target: Target, text: string, label: string): Promise<void>;
+    };
+};
+export type WebDriverServer = {
+    /** The server binary: `safaridriver`, `chromedriver`, `geckodriver`, `appium`. */
+    command: string;
+    /** `{port}` is replaced with the port. Defaults: `--port {port}` (`--port={port}` for chromedriver). */
+    args?: string[];
+    port?: number;
+    readyTimeoutMs?: number;
+};
+export type WebDriverDriverOptions = {
+    /** A running WebDriver server; or set `server` to start one for the run. */
+    url?: string;
+    server?: WebDriverServer;
+    /** W3C capabilities (`alwaysMatch`), e.g. `{ browserName: 'safari' }` or Appium's `platformName`, `appium:app`. */
+    capabilities: Record<string, unknown>;
+    /** `web` resolves signals in the DOM; `native` resolves them in the accessibility tree. Inferred from the capabilities. */
+    mode?: Mode;
+    /** Where `goto` paths resolve; the implementation's setup decides where to open. */
+    baseUrl?: string | (() => string | Promise<string>);
+    /** `per-attempt` (default) starts a fresh session (browser or app) for every path attempt; `per-run` reuses one. */
+    session?: 'per-attempt' | 'per-run';
+    /** Clips: `frames` (default) encodes screenshots with FFmpeg; `appium` uses Appium's screen recorder; `none`. */
+    recording?: 'frames' | 'appium' | 'none';
+    /** How long a tap waits for its target, in milliseconds (default 15 000). */
+    actionTimeoutMs?: number;
+    name?: string;
+    pacing?: {
+        before: number;
+        after: number;
+    };
+    /**
+     * Sessions open at once (one per worker): raise it for a grid or several devices. 1 when
+     * omitted, and always 1 with a per-run session.
+     */
+    concurrency?: number;
+};
+/** A signal as a native locator: test IDs are accessibility identifiers, text is any label, value or text. */
+export declare function nativeLocator(signal: Signal): Locator | null;
+/**
+ * Drive anything that speaks W3C WebDriver: Safari (safaridriver ships with macOS), Chrome,
+ * Firefox and Edge, or a native iOS or Android app through Appium. Signals resolve in the DOM
+ * for web sessions and in the accessibility tree for native ones (test IDs are accessibility
+ * identifiers), so one implementation style covers both. Screenshots and the page source are
+ * standard; clips are encoded from screenshots, or come from Appium's screen recorder.
+ */
+export declare function webdriverDriver(options: WebDriverDriverOptions): Driver<WebDriverContext>;
+/** A state recognised from signals or locators: every `all` visible and no `none` visible. */
+export declare const screen: (spec: import('../../core/src/signals.js').ScreenSpec<WebDriverContext, Target>) => import('../../core/src/index.js').StateImplementation<WebDriverContext>;