Run and inspect

Run the whole suite headlessly, or keep the browser open while you work:

dyno                    # run and exit
dyno --ui               # inspect the app and results
dyno --ui --watch        # rerun when tests or helpers change

Dyno starts the app and stops the processes it owns when you finish. --ui keeps the session open for reruns; press Ctrl-C to stop it.

Open the reporter

Press Ctrl+Shift+D in the app. Dyno finishes the current test, then opens the reporter over it. The app keeps its full viewport underneath.

Start with the file/suite overview, then open a test’s Output, Timings or Application view. You can rerun a test, suite, file or failed selection. Search and filters stay in the URL.

Turn on Pause on failure in Run options to inspect a failing app. Continue hides the reporter before the next test. Stop cancels the run and starts cleanup. Pausing leaves app timers and requests running.

The CLI also prints a separate reporter URL. Open it in another tab if you’d rather keep the app uncovered. A completed interactive run keeps each worker’s last app available; rerun an earlier test to inspect it again.

Repeat while developing

Exercise a workflow repeatedly, or vary the order of a whole selection:

dyno --test 'checkout' --repeat 100
dyno --suite Checkout --repeat 100 --random
dyno --suite Checkout --repeat 100 --seed checkout-race
dyno --repeat 100 --replay .dyno/reports/<run-id>/schedule.json

--repeat N runs the complete selection N times, including the first run. It supports managed headless runs; combining it with --ui, --manual, or --watch fails before startup. Tests keep their normal hooks and per-execution fixture preparation. Setup runs once, and browser storage, servers, and project worker resources survive between rounds. Keep scenario reset and backend cleanup in your project.

Each automatic execution removes its test runtime and parks the app before project draining, including the final test. A round must finish cleanup and save its results before the next starts. Each round gets its own runTimeout. A failed test stays in the batch result while later rounds continue; cleanup, browser, preparation, persistence, or deadline failures stop repetition. Ctrl-C saves accepted partial results and stops further rounds.

Without a seed, rounds use declared priority. With --seed, round one uses that literal seed and later rounds derive repeatable seeds from it. --random generates and prints a root seed; pass it to --seed to reproduce the series. The count does not affect seed derivation, so rerunning through the first failing round preserves the prefix. Repeated --replay keeps the recorded worker queues fixed.

The summary prints commands to replay the first failing round and rerun the original selection through it. A focused rerun can remove the predecessor that caused a failure. A round-only replay also omits state accumulated in earlier rounds. Seeds reproduce priority, and schedules reproduce queues; neither controls app randomness, backend data, or asynchronous timing. Keep app code and data stable while collecting results. Dyno pins the test bundle, not the running application.

See saved reports for batch counts, schedules, images, and evidence limits. Passing many times is evidence under those conditions; it does not prove a test can never fail.

Bring your own browser

dyno --manual --host 0.0.0.0

Open the printed URL and click Start tests if the popup was blocked. Keep both the app and companion windows open. Closing or reloading the companion interrupts the run; start a new one afterward.

See browser setup for manual-mode limits. Use editing and debugging for watch mode and in-test pauses, or dyno --help for selection and other options.

Use the output in CI

dyno --json writes one JSON event per stdout line. Config, setup, teardown and app logs go to stderr. Use the process exit code as the outcome: 0 passes, 1 fails, 130 means SIGINT, and 143 means SIGTERM. Cleanup failure exits 1, including after interruption.

Saved reports give you portable HTML, JSON, JUnit and images after the session stops.