@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/webdriver/src/driver.js

@@ -0,0 +1,230 @@
+import { spawn } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import path from 'node:path';
+import { recordFrames } from '../../core/src/index.js';
+import { DOM_PROBE, describeSignal, signatureScreen, toWire } from '../../core/src/signals.js';
+import { waitForServer, WebDriverSession } from './protocol.js';
+function inferMode(capabilities) {
+    if (capabilities.browserName)
+        return 'web';
+    const native = ['appium:app', 'appium:bundleId', 'appium:appPackage', 'appium:appActivity'].some((k) => k in capabilities);
+    return native || /^(ios|android)$/i.test(String(capabilities.platformName ?? '')) ? 'native' : 'web';
+}
+const xpathLiteral = (value) => {
+    if (!value.includes("'"))
+        return `'${value}'`;
+    if (!value.includes('"'))
+        return `"${value}"`;
+    return `concat(${value
+        .split("'")
+        .map((part) => `'${part}'`)
+        .join(`, "'", `)})`;
+};
+/** iOS (XCUITest) and Android (UiAutomator2) element types for the common roles. */
+const NATIVE_ROLES = {
+    button: ['XCUIElementTypeButton', 'android.widget.Button', 'android.widget.ImageButton'],
+    textbox: ['XCUIElementTypeTextField', 'XCUIElementTypeSecureTextField', 'XCUIElementTypeTextView', 'android.widget.EditText'],
+    checkbox: ['XCUIElementTypeSwitch', 'android.widget.CheckBox', 'android.widget.Switch'],
+    switch: ['XCUIElementTypeSwitch', 'android.widget.Switch'],
+    link: ['XCUIElementTypeLink'],
+    img: ['XCUIElementTypeImage', 'android.widget.ImageView'],
+    heading: []
+};
+const TEXT_ATTRIBUTES = ['label', 'name', 'value', 'text', 'content-desc'];
+/** A signal as a native locator: test IDs are accessibility identifiers, text is any label, value or text. */
+export function nativeLocator(signal) {
+    const name = describeSignal(signal);
+    if ('testId' in signal)
+        return { using: 'accessibility id', value: signal.testId, name };
+    if ('css' in signal)
+        throw new Error(`${name}: CSS selectors only work in web sessions`);
+    const match = 'label' in signal ? signal.label : 'role' in signal ? signal.name : signal.text;
+    const exact = 'exact' in signal && signal.exact === true;
+    if (match instanceof RegExp)
+        return null;
+    const types = 'role' in signal ? (NATIVE_ROLES[signal.role] ?? []) : [];
+    const typeTest = types.length ? `(${types.map((t) => `self::${t}`).join(' or ')})` : '';
+    const attributes = 'label' in signal ? ['label', 'name', 'content-desc', 'hint'] : TEXT_ATTRIBUTES;
+    const textTest = match === undefined ? '' : `(${attributes.map((a) => (exact ? `@${a}=${xpathLiteral(match)}` : `contains(@${a}, ${xpathLiteral(match)})`)).join(' or ')})`;
+    const tests = [typeTest, textTest].filter(Boolean).join(' and ');
+    return { using: 'xpath', value: `//*${tests ? `[${tests}]` : ''}`, name };
+}
+/** Elements of an Appium page source whose text attributes match a pattern and that are shown. */
+function sourceMatches(source, pattern) {
+    const results = [];
+    for (const tag of source.matchAll(/<([\w.]+)((?:\s+[\w:-]+="[^"]*")*)\s*\/?>/g)) {
+        const attributes = Object.fromEntries([...(tag[2] ?? '').matchAll(/([\w:-]+)="([^"]*)"/g)].map((m) => [m[1], m[2]]));
+        if (attributes.visible === 'false' || attributes.displayed === 'false')
+            continue;
+        if (TEXT_ATTRIBUTES.some((a) => attributes[a] !== undefined && pattern.test(attributes[a])))
+            results.push(attributes);
+    }
+    return results;
+}
+const isLocator = (target) => 'using' in target;
+const describe = (target) => (isLocator(target) ? (target.name ?? `${target.using} ${target.value}`) : describeSignal(target));
+async function freePort() {
+    return new Promise((resolve, reject) => {
+        const probe = createServer();
+        probe.once('error', reject);
+        probe.listen(0, '127.0.0.1', () => {
+            const address = probe.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            probe.close(() => resolve(port));
+        });
+    });
+}
+function contextFor(session, mode, baseUrl, timeline, timeoutMs) {
+    const resolve = async (target) => {
+        if (isLocator(target)) {
+            for (const element of await session.findElements(target))
+                if (await session.isDisplayed(element).catch(() => false))
+                    return element;
+            return null;
+        }
+        if (mode === 'web') {
+            const found = (await session.execute(`return (${DOM_PROBE})(arguments[0], arguments[1], true)`, [toWire(target), true]));
+            return found?.visible ? session.elementId(found.element) : null;
+        }
+        const locator = nativeLocator(target);
+        if (locator)
+            return resolve(locator);
+        const pattern = 'label' in target ? target.label : 'role' in target ? target.name : 'text' in target ? target.text : undefined;
+        if (!(pattern instanceof RegExp))
+            return null;
+        const [first] = sourceMatches(await session.source(), pattern);
+        const key = first && TEXT_ATTRIBUTES.find((a) => first[a] !== undefined && pattern.test(first[a]));
+        return key ? resolve({ using: 'xpath', value: `//*[@${key}=${xpathLiteral(first[key])}]` }) : null;
+    };
+    const waitFor = async (target) => {
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const element = await resolve(target).catch(() => null);
+            if (element)
+                return element;
+            if (Date.now() > deadline)
+                throw new Error(`${describe(target)} is not on screen`);
+            await new Promise((r) => setTimeout(r, 200));
+        }
+    };
+    const centre = async (element) => {
+        const r = await session.rect(element).catch(() => null);
+        return r ? { x: r.x + r.width / 2, y: r.y + r.height / 2 } : {};
+    };
+    return {
+        session,
+        mode,
+        baseUrl,
+        goto: (url) => session.navigate(baseUrl ? new URL(url, baseUrl).href : url),
+        find: resolve,
+        isVisible: async (target) => Boolean(await resolve(target)),
+        user: {
+            async tap(target, label) {
+                const element = await waitFor(target);
+                timeline.add({ kind: 'tap', label, ...(await centre(element)) });
+                await session.click(element);
+            },
+            async type(target, text, label) {
+                const element = await waitFor(target);
+                timeline.add({ kind: 'type', label, text, ...(await centre(element)) });
+                await session.click(element).catch(() => undefined);
+                await session.sendKeys(element, text);
+            }
+        }
+    };
+}
+/**
+ * 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 function webdriverDriver(options) {
+    const mode = options.mode ?? inferMode(options.capabilities);
+    const timeoutMs = options.actionTimeoutMs ?? 15_000;
+    let server = null;
+    let starting = null;
+    let shared = null;
+    const serverUrl = () => (starting ??= startServer());
+    const startServer = async () => {
+        if (server)
+            return server.url;
+        if (options.url) {
+            server = { url: options.url, process: null };
+            return server.url;
+        }
+        if (!options.server)
+            throw new Error('webdriverDriver needs `url` (a running WebDriver server) or `server` (a command to start one)');
+        const port = options.server.port ?? (await freePort());
+        const defaults = /chromedriver|msedgedriver/.test(options.server.command) ? ['--port={port}'] : ['--port', '{port}'];
+        const args = (options.server.args ?? defaults).map((a) => a.replaceAll('{port}', String(port)));
+        const child = spawn(options.server.command, args, { stdio: 'ignore' });
+        const url = `http://127.0.0.1:${port}`;
+        const exited = new Promise((_, reject) => {
+            child.once('error', (e) => reject(new Error(`Could not start ${options.server.command}: ${e.message}`)));
+            child.once('exit', (code) => reject(new Error(`${options.server.command} exited with code ${code}`)));
+        });
+        await Promise.race([waitForServer(url, options.server.readyTimeoutMs ?? 30_000), exited]);
+        server = { url, process: child };
+        return url;
+    };
+    const startSession = async () => WebDriverSession.create(await serverUrl(), options.capabilities);
+    return {
+        name: options.name ?? (mode === 'native' ? `webdriver:${String(options.capabilities.platformName ?? 'native').toLowerCase()}` : `webdriver:${String(options.capabilities.browserName ?? 'browser')}`),
+        pacing: options.pacing ?? { before: 400, after: 900 },
+        concurrency: options.session === 'per-run' ? 1 : (options.concurrency ?? 1),
+        async open({ timeline }) {
+            const session = options.session === 'per-run' ? (shared ??= await startSession()) : await startSession();
+            const baseUrl = typeof options.baseUrl === 'function' ? await options.baseUrl() : options.baseUrl;
+            return contextFor(session, mode, baseUrl, timeline, timeoutMs);
+        },
+        async close(ctx) {
+            if (options.session !== 'per-run')
+                await ctx.session.delete().catch(() => undefined);
+        },
+        async screenshot(ctx, file) {
+            const png = await ctx.session.screenshot();
+            mkdirSync(path.dirname(file), { recursive: true });
+            writeFileSync(file, png);
+            return { png: file };
+        },
+        ...(options.recording === 'none'
+            ? {}
+            : {
+                async record(ctx, workDirectory) {
+                    if (options.recording !== 'appium')
+                        return recordFrames(() => ctx.session.screenshot(), workDirectory);
+                    await ctx.session.command('POST', '/appium/start_recording_screen', { options: { forceRestart: true } });
+                    const started = Date.now();
+                    return {
+                        async stop(output) {
+                            const video = await ctx.session.command('POST', '/appium/stop_recording_screen', {}).catch(() => null);
+                            if (!video)
+                                return null;
+                            mkdirSync(path.dirname(output), { recursive: true });
+                            writeFileSync(output, Buffer.from(String(video), 'base64'));
+                            return { video: output, durationMs: Date.now() - started };
+                        }
+                    };
+                }
+            }),
+        async text(ctx) {
+            if (ctx.mode === 'web')
+                return String(await ctx.session.execute('return document.body ? document.body.innerText : ""'));
+            return sourceMatches(await ctx.session.source(), /\S/)
+                .map((a) => TEXT_ATTRIBUTES.map((k) => a[k]).find(Boolean))
+                .join('\n');
+        },
+        async dispose() {
+            await shared?.delete().catch(() => undefined);
+            shared = null;
+            server?.process?.kill();
+            server = null;
+            starting = null;
+        }
+    };
+}
+/** A state recognised from signals or locators: every `all` visible and no `none` visible. */
+export const screen = signatureScreen(async (ctx, target) => Boolean(await ctx.find(target)), describe);

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

@@ -0,0 +1,11 @@
+import type { Locator } from './protocol.js';
+export { webdriverDriver, screen, nativeLocator, type Mode, type Target, type WebDriverContext, type WebDriverDriverOptions, type WebDriverServer } from './driver.js';
+export { WebDriverSession, WebDriverError, waitForServer, ELEMENT_KEY, type Locator, type Rect } from './protocol.js';
+export { css, label, role, testId, text, describeSignal, type Signal } from '../../core/src/signals.js';
+/** Appium: an accessibility identifier (iOS) or content description (Android); React Native's `testID`. */
+export declare const accessibilityId: (value: string) => Locator;
+export declare const xpath: (value: string) => Locator;
+/** Appium iOS: an NSPredicate over the element tree, e.g. `label == "Book" AND type == "XCUIElementTypeButton"`. */
+export declare const iosPredicate: (value: string) => Locator;
+/** Appium Android: a UiSelector expression, e.g. `new UiSelector().text("Book")`. */
+export declare const androidUiAutomator: (value: string) => Locator;

package/dist/webdriver/src/index.js

@@ -0,0 +1,10 @@
+export { webdriverDriver, screen, nativeLocator } from './driver.js';
+export { WebDriverSession, WebDriverError, waitForServer, ELEMENT_KEY } from './protocol.js';
+export { css, label, role, testId, text, describeSignal } from '../../core/src/signals.js';
+/** Appium: an accessibility identifier (iOS) or content description (Android); React Native's `testID`. */
+export const accessibilityId = (value) => ({ using: 'accessibility id', value, name: `accessibility id "${value}"` });
+export const xpath = (value) => ({ using: 'xpath', value, name: `xpath ${value}` });
+/** Appium iOS: an NSPredicate over the element tree, e.g. `label == "Book" AND type == "XCUIElementTypeButton"`. */
+export const iosPredicate = (value) => ({ using: '-ios predicate string', value, name: `predicate ${value}` });
+/** Appium Android: a UiSelector expression, e.g. `new UiSelector().text("Book")`. */
+export const androidUiAutomator = (value) => ({ using: '-android uiautomator', value, name: `uiautomator ${value}` });

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

@@ -0,0 +1,60 @@
+/**
+ * A dependency-free client for the W3C WebDriver protocol (https://www.w3.org/TR/webdriver2/), the
+ * standard every browser driver speaks (safaridriver, chromedriver, geckodriver, msedgedriver) and
+ * Appium extends for native iOS and Android apps.
+ */
+/** The W3C web element identifier key. */
+export declare const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
+/**
+ * A location strategy and value. W3C strategies: `css selector`, `xpath`, `link text`,
+ * `partial link text`, `tag name`. Appium adds `accessibility id`, `id`, `class name`,
+ * `-ios predicate string`, `-ios class chain` and `-android uiautomator`.
+ */
+export type Locator = {
+    using: string;
+    value: string;
+    name?: string;
+};
+export declare class WebDriverError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+}
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare class WebDriverSession {
+    readonly serverUrl: string;
+    readonly id: string;
+    readonly capabilities: Record<string, unknown>;
+    timeoutMs: number;
+    constructor(serverUrl: string, id: string, capabilities: Record<string, unknown>, timeoutMs?: number);
+    /** New Session: `capabilities` go in `alwaysMatch`. */
+    static create(serverUrl: string, capabilities: Record<string, unknown>, timeoutMs?: number): Promise<WebDriverSession>;
+    /** Any session command, for what this client does not wrap (extensions such as `appium/...`). */
+    command(method: 'GET' | 'POST' | 'DELETE', path: string, body?: unknown): Promise<unknown>;
+    navigate(url: string): Promise<void>;
+    currentUrl(): Promise<string>;
+    refresh(): Promise<void>;
+    back(): Promise<void>;
+    findElements(locator: Locator): Promise<string[]>;
+    isDisplayed(element: string): Promise<boolean>;
+    rect(element: string): Promise<Rect>;
+    click(element: string): Promise<void>;
+    clear(element: string): Promise<void>;
+    sendKeys(element: string, text: string): Promise<void>;
+    elementText(element: string): Promise<string>;
+    /** Execute Script (web contexts); element references in the result come back as element ids. */
+    execute(script: string, args?: unknown[]): Promise<unknown>;
+    elementId(value: unknown): string | null;
+    source(): Promise<string>;
+    screenshot(): Promise<Buffer<ArrayBuffer>>;
+    /** A tap at viewport coordinates through W3C Actions (a touch pointer). */
+    tapAt(x: number, y: number): Promise<void>;
+    delete(): Promise<void>;
+}
+/** Wait until a WebDriver server answers `GET /status` as ready. */
+export declare function waitForServer(serverUrl: string, timeoutMs?: number): Promise<void>;

package/dist/webdriver/src/protocol.js

@@ -0,0 +1,146 @@
+/**
+ * A dependency-free client for the W3C WebDriver protocol (https://www.w3.org/TR/webdriver2/), the
+ * standard every browser driver speaks (safaridriver, chromedriver, geckodriver, msedgedriver) and
+ * Appium extends for native iOS and Android apps.
+ */
+/** The W3C web element identifier key. */
+export const ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
+export class WebDriverError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.status = status;
+    }
+}
+const elementIdOf = (value) => value && typeof value === 'object' && ELEMENT_KEY in value ? String(value[ELEMENT_KEY]) : null;
+async function call(url, method, body, timeoutMs) {
+    const response = await fetch(url, {
+        method,
+        headers: body === undefined ? {} : { 'content-type': 'application/json; charset=utf-8' },
+        signal: AbortSignal.timeout(timeoutMs),
+        ...(body === undefined ? {} : { body: JSON.stringify(body) })
+    });
+    const text = await response.text();
+    let parsed = {};
+    try {
+        parsed = text ? JSON.parse(text) : {};
+    }
+    catch {
+        throw new WebDriverError('invalid response', `${method} ${url} answered ${response.status} with non-JSON`, response.status);
+    }
+    const value = parsed.value;
+    if (!response.ok || (value && typeof value === 'object' && 'error' in value)) {
+        const error = (value ?? {});
+        throw new WebDriverError(error.error ?? 'unknown error', error.message ?? `${method} ${url} answered ${response.status}`, response.status);
+    }
+    return value;
+}
+export class WebDriverSession {
+    serverUrl;
+    id;
+    capabilities;
+    timeoutMs;
+    constructor(serverUrl, id, capabilities, timeoutMs = 60_000) {
+        this.serverUrl = serverUrl.replace(/\/$/, '');
+        this.id = id;
+        this.capabilities = capabilities;
+        this.timeoutMs = timeoutMs;
+    }
+    /** New Session: `capabilities` go in `alwaysMatch`. */
+    static async create(serverUrl, capabilities, timeoutMs = 120_000) {
+        const value = (await call(`${serverUrl.replace(/\/$/, '')}/session`, 'POST', { capabilities: { alwaysMatch: capabilities } }, timeoutMs));
+        return new WebDriverSession(serverUrl, value.sessionId, value.capabilities ?? {});
+    }
+    /** Any session command, for what this client does not wrap (extensions such as `appium/...`). */
+    command(method, path, body) {
+        return call(`${this.serverUrl}/session/${this.id}${path}`, method, method === 'POST' ? (body ?? {}) : undefined, this.timeoutMs);
+    }
+    async navigate(url) {
+        await this.command('POST', '/url', { url });
+    }
+    async currentUrl() {
+        return String(await this.command('GET', '/url'));
+    }
+    async refresh() {
+        await this.command('POST', '/refresh');
+    }
+    async back() {
+        await this.command('POST', '/back');
+    }
+    async findElements(locator) {
+        const value = await this.command('POST', '/elements', { using: locator.using, value: locator.value });
+        return Array.isArray(value) ? value.map(elementIdOf).filter((id) => Boolean(id)) : [];
+    }
+    async isDisplayed(element) {
+        return Boolean(await this.command('GET', `/element/${element}/displayed`));
+    }
+    async rect(element) {
+        return (await this.command('GET', `/element/${element}/rect`));
+    }
+    async click(element) {
+        await this.command('POST', `/element/${element}/click`);
+    }
+    async clear(element) {
+        await this.command('POST', `/element/${element}/clear`);
+    }
+    async sendKeys(element, text) {
+        await this.command('POST', `/element/${element}/value`, { text });
+    }
+    async elementText(element) {
+        return String(await this.command('GET', `/element/${element}/text`));
+    }
+    /** Execute Script (web contexts); element references in the result come back as element ids. */
+    async execute(script, args = []) {
+        return this.command('POST', '/execute/sync', { script, args });
+    }
+    elementId(value) {
+        return elementIdOf(value);
+    }
+    async source() {
+        return String(await this.command('GET', '/source'));
+    }
+    async screenshot() {
+        return Buffer.from(String(await this.command('GET', '/screenshot')), 'base64');
+    }
+    /** A tap at viewport coordinates through W3C Actions (a touch pointer). */
+    async tapAt(x, y) {
+        await this.command('POST', '/actions', {
+            actions: [
+                {
+                    type: 'pointer',
+                    id: 'finger',
+                    parameters: { pointerType: 'touch' },
+                    actions: [
+                        { type: 'pointerMove', duration: 0, x: Math.round(x), y: Math.round(y) },
+                        { type: 'pointerDown', button: 0 },
+                        { type: 'pause', duration: 50 },
+                        { type: 'pointerUp', button: 0 }
+                    ]
+                }
+            ]
+        });
+    }
+    async delete() {
+        await call(`${this.serverUrl}/session/${this.id}`, 'DELETE', undefined, this.timeoutMs);
+    }
+}
+/** Wait until a WebDriver server answers `GET /status` as ready. */
+export async function waitForServer(serverUrl, timeoutMs = 30_000) {
+    const deadline = Date.now() + timeoutMs;
+    let last = 'no answer';
+    while (Date.now() < deadline) {
+        try {
+            const value = (await call(`${serverUrl.replace(/\/$/, '')}/status`, 'GET', undefined, 2_000));
+            if (value?.ready !== false)
+                return;
+            last = value.message ?? 'not ready';
+        }
+        catch (error) {
+            last = error instanceof Error ? error.message : String(error);
+        }
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    throw new Error(`The WebDriver server at ${serverUrl} did not become ready: ${last}`);
+}

package/package.json

@@ -1,6 +1,183 @@
 {
   "name": "@crvouga/atlas",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Atlas: executable statecharts. Spec a product's flows as statecharts, run them against the real app with any driver, and browse what happened.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "./packages/visualizer/**",
+    "**/*.css"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crvouga/atlas.git"
+  },
+  "homepage": "https://github.com/crvouga/atlas#readme",
+  "bugs": {
+    "url": "https://github.com/crvouga/atlas/issues"
+  },
+  "keywords": [
+    "statecharts",
+    "scxml",
+    "xstate",
+    "model-based-testing",
+    "e2e",
+    "playwright",
+    "webdriver",
+    "visualizer"
+  ],
+  "packageManager": "bun@1.4.2",
+  "engines": {
+    "node": ">=22.18.0",
+    "bun": ">=1.2.0"
+  },
+  "bin": {
+    "atlas": "./packages/core/bin/atlas.mjs",
+    "atlas-visualizer": "./packages/visualizer/bin/atlas-visualizer.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core/src/index.d.ts",
+      "default": "./dist/core/src/index.js"
+    },
+    "./spec": {
+      "types": "./dist/core/src/spec/index.d.ts",
+      "default": "./dist/core/src/spec/index.js"
+    },
+    "./signals": {
+      "types": "./dist/core/src/signals.d.ts",
+      "default": "./dist/core/src/signals.js"
+    },
+    "./cli": {
+      "types": "./dist/core/src/cli.d.ts",
+      "default": "./dist/core/src/cli.js"
+    },
+    "./playwright": {
+      "types": "./dist/playwright/src/index.d.ts",
+      "default": "./dist/playwright/src/index.js"
+    },
+    "./bun": {
+      "types": "./dist/bun/src/index.d.ts",
+      "default": "./dist/bun/src/index.js"
+    },
+    "./webdriver": {
+      "types": "./dist/webdriver/src/index.d.ts",
+      "default": "./dist/webdriver/src/index.js"
+    },
+    "./detox": {
+      "types": "./dist/detox/src/index.d.ts",
+      "default": "./dist/detox/src/index.js"
+    },
+    "./vitest": {
+      "types": "./dist/vitest/src/index.d.ts",
+      "default": "./dist/vitest/src/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema/src/index.d.ts",
+      "default": "./dist/schema/src/index.js"
+    },
+    "./reports/*": {
+      "types": "./dist/reports/src/*.d.ts",
+      "default": "./dist/reports/src/*.js"
+    },
+    "./schemas/*": "./packages/schema/schemas/*"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": [
+    "dist",
+    "packages/core/bin",
+    "packages/schema/schemas",
+    "packages/visualizer/bin",
+    "packages/visualizer/example",
+    "packages/visualizer/fixtures",
+    "packages/visualizer/index.html",
+    "packages/visualizer/scripts",
+    "packages/visualizer/src",
+    "packages/visualizer/vite",
+    "packages/visualizer/vite.config.ts",
+    "packages/*/README.md",
+    "packages/reports/STORAGE.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "bun scripts/build-package.ts",
+    "test": "bun test && bun test --cwd packages/visualizer --preload ./tests/preload.ts tests",
+    "type-check": "for dir in packages/* scripts examples/todo; do tsc --noEmit -p \"$dir\" || exit 1; done",
+    "schemas": "bun packages/schema/scripts/emit-json-schemas.ts",
+    "viz:dev": "cd packages/visualizer && INIT_CWD=\"$OLDPWD\" bun --bun vite --configLoader runner",
+    "viz:build": "cd packages/visualizer && INIT_CWD=\"$OLDPWD\" bun --bun vite build --configLoader runner",
+    "viz:publish-data": "bun packages/visualizer/scripts/publish-data.ts",
+    "viz:fixtures": "bun packages/visualizer/scripts/make-fixtures.ts",
+    "example:start": "bun examples/todo/server.ts",
+    "example:lint": "bun --cwd examples/todo ../../packages/core/bin/atlas.mjs lint --require-implementations",
+    "example:plan": "bun --cwd examples/todo ../../packages/core/bin/atlas.mjs plan",
+    "example:fast": "bun --cwd examples/todo ../../packages/core/bin/atlas.mjs run --mode fast",
+    "example:run": "bun --cwd examples/todo ../../packages/core/bin/atlas.mjs run --mode showcase",
+    "example:clients": "bun --cwd examples/todo ../../packages/core/bin/atlas.mjs run --config clients/atlas.config.ts --mode showcase",
+    "example:clients:bun": "ATLAS_DESKTOP=bun bun --cwd examples/todo ../../packages/core/bin/atlas.mjs run --config clients/atlas.config.ts --mode showcase",
+    "atlas:run": "status=0; bun run example:clients || status=$?; bun run example:run || status=$?; exit $status",
+    "atlas:viz": "bun packages/visualizer/bin/atlas-visualizer.mjs dev --specs examples/todo/specs --runs examples/todo/atlas-runs",
+    "release:plan": "bun scripts/release/plan.ts",
+    "release:publish": "bun scripts/release/publish.ts",
+    "release:smoke": "bun scripts/release/consumer-smoke.ts",
+    "release:seed": "bun scripts/release/seed.ts",
+    "health": "bun scripts/health/cli.ts",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@cucumber/gherkin": "^42.0.1",
+    "@cucumber/messages": "^34.2.1",
+    "@radix-ui/react-collapsible": "^1.1.21",
+    "@radix-ui/react-dialog": "^1.2.0",
+    "@radix-ui/react-dropdown-menu": "^2.1.25",
+    "@radix-ui/react-popover": "^1.2.0",
+    "@radix-ui/react-tabs": "^1.1.22",
+    "@radix-ui/react-tooltip": "^1.3.0",
+    "@tanstack/query-persist-client-core": "^5.104.0",
+    "@tanstack/react-query": "^5.101.4",
+    "@tanstack/react-router": "^1.170.41",
+    "@tanstack/solid-query": "^5.104.0",
+    "@vitejs/plugin-react": "5.2.0",
+    "@xyflow/react": "^12.11.5",
+    "cmdk": "^1.1.1",
+    "elkjs": "0.12.0",
+    "fast-xml-parser": "5.11.0",
+    "hono": "^4.13.9",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "solid-js": "^1.9.15",
+    "tsx": "4.23.13",
+    "vite": "7.3.6",
+    "xstate": "5.33.2",
+    "yaml": "^2.9.0",
+    "zod": "^3.25.76",
+    "zustand": "^5.0.15"
+  },
+  "peerDependencies": {
+    "detox": ">=20",
+    "playwright": ">=1.45"
+  },
+  "peerDependenciesMeta": {
+    "detox": {
+      "optional": true
+    },
+    "playwright": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.8.1",
+    "@commitlint/config-conventional": "19.8.1",
+    "@types/bun": "1.4.3",
+    "@types/node": "^22.20.3",
+    "@types/react": "19.2.7",
+    "@types/react-dom": "19.2.3",
+    "happy-dom": "20.11.1",
+    "husky": "^9.1.7",
+    "playwright": "1.60.0",
+    "typescript": "^5.9.3"
+  }
+}