One built-in reporter by name, or false. An instance cannot cross a socket.

Several built-in reporters by name. Mutually exclusive with reporter, as it is locally.

Elixir's Task.async_stream/3, living at its JS-idiomatic home: maps fn over the source with at most maxConcurrency invocations in flight, lazily — nothing starts until a consumer pulls, and the window refills only as results are taken. Results keep source order by default (ordered: false yields completion order — faster when element durations vary). Each element may deadline (timeoutMs) into a declared Failure('AsyncTimeout') element — the railway, not a crash; the element's signal fires so cancellation-aware work stops. A throw from fn stays a bug. Failure elements from the source pass through unmapped.

The one push source: a handle whose producer emits whenever it likes, and a Stream that consumes what it emitted. Every other builder pulls — unfold, resource and iterate all ask for the next element — but the most common real source in JS cannot be asked: an EventEmitter, a WebSocket, fs.watch, SSE, a browser running tests.

StreamClass#chunkBy as a static: Stream.chunkBy(source, …) is Stream.from(source).chunkBy(…).

StreamClass#chunkEvery as a static: Stream.chunkEvery(source, …) is Stream.from(source).chunkEvery(…).

StreamClass#chunkWhile as a static: Stream.chunkWhile(source, …) is Stream.from(source).chunkWhile(…).

StreamClass#collect as a static: Stream.collect(source, …) is Stream.from(source).collect(…).

Concatenates sources in order — Elixir's Stream.concat, variadic.

Repeats a re-iterable source forever — always bound it (take, takeWhile).

StreamClass#dedup as a static: Stream.dedup(source, …) is Stream.from(source).dedup(…).

StreamClass#dedupBy as a static: Stream.dedupBy(source, …) is Stream.from(source).dedupBy(…).

StreamClass#drop as a static: Stream.drop(source, …) is Stream.from(source).drop(…).

StreamClass#dropEvery as a static: Stream.dropEvery(source, …) is Stream.from(source).dropEvery(…).

StreamClass#dropWhile as a static: Stream.dropWhile(source, …) is Stream.from(source).dropWhile(…).

count copies of one value.

StreamClass#every as a static: Stream.every(source, …) is Stream.from(source).every(…).

StreamClass#filter as a static: Stream.filter(source, …) is Stream.from(source).filter(…).

StreamClass#find as a static: Stream.find(source, …) is Stream.from(source).find(…).

StreamClass#flatMap as a static: Stream.flatMap(source, …) is Stream.from(source).flatMap(…).

StreamClass#forEach as a static: Stream.forEach(source, …) is Stream.from(source).forEach(…).

Lifts a source into a Stream. Elements that are Failures are the E channel from the start; everything else is T.

The infinite integers offset, offset + 1, … — Elixir's Stream.from_index/1.

StreamClass#intersperse as a static: Stream.intersperse(source, …) is Stream.from(source).intersperse(…).

Emits 0, 1, 2, … every ms milliseconds, forever — Elixir's Stream.interval/1, on setTimeout (universal). Infinite: always bound it.

StreamClass#into as a static: Stream.into(source, …) is Stream.from(source).into(…).

seed, fn(seed), fn(fn(seed)), … — Elixir's Stream.iterate/2, infinite.

Decodes a byte stream into text lines — the front door for NDJSON, logs, and SSE-ish feeds. Handles multi-byte characters and lines split across chunk boundaries; the final unterminated line is flushed.

StreamClass#map as a static: Stream.map(source, …) is Stream.from(source).map(…).

StreamClass#mapConcurrent as a static: Stream.mapConcurrent(source, …) is Stream.from(source).mapConcurrent(…).

StreamClass#mapEvery as a static: Stream.mapEvery(source, …) is Stream.from(source).mapEvery(…).

StreamClass#partition as a static: Stream.partition(source, …) is Stream.from(source).partition(…).

StreamClass#reduce as a static: Stream.reduce(source, …) is Stream.from(source).reduce(…).

StreamClass#reject as a static: Stream.reject(source, …) is Stream.from(source).reject(…).

Calls fn for each pull, forever — Elixir's Stream.repeatedly/1.

unfold with lifecycle hooks — Elixir's Stream.resource/3: start runs on first pull, next is unfold's step, and after ALWAYS runs — normal end, early take, or a throw. (Plain generators already get this via try/finally; resource is for when the setup/teardown pair deserves to be explicit.)

StreamClass#results as a static: Stream.results(source, …) is Stream.from(source).results(…).

StreamClass#run as a static: Stream.run(source, …) is Stream.from(source).run(…).

Emits the running fold of the values — Elixir's Stream.scan; without initial the first value seeds the accumulator. Failures pass through and leave the accumulator untouched.

StreamClass#some as a static: Stream.some(source, …) is Stream.from(source).some(…).

StreamClass#take as a static: Stream.take(source, …) is Stream.from(source).take(…).

StreamClass#takeEvery as a static: Stream.takeEvery(source, …) is Stream.from(source).takeEvery(…).

StreamClass#takeWhile as a static: Stream.takeWhile(source, …) is Stream.from(source).takeWhile(…).

StreamClass#tap as a static: Stream.tap(source, …) is Stream.from(source).tap(…).

StreamClass#through as a static: Stream.through(source, …) is Stream.from(source).through(…).

Emits a single 0 after ms milliseconds, then ends — Elixir's Stream.timer/1.

Elixir's Stream.unfold/2: grow a lazy stream from a seed. next(state) returns [element, nextState] to emit and continue, or null to end; return [failure, null] to emit a declared failure and stop. Nothing runs until a consumer pulls — pagination only fetches the pages the consumer actually reaches.

StreamClass#uniq as a static: Stream.uniq(source, …) is Stream.from(source).uniq(…).

StreamClass#uniqBy as a static: Stream.uniqBy(source, …) is Stream.from(source).uniqBy(…).

StreamClass#withIndex as a static: Stream.withIndex(source, …) is Stream.from(source).withIndex(…).

Zips sources in lockstep, ending at the shortest (Elixir's Stream.zip) and closing the longer sources so their cleanup runs. JS divergences: sources are pulled sequentially per slot, and a failure element passes through bare without consuming from the other sources — failures cannot pair.

zip plus a combiner — Elixir's Stream.zip_with; the tuple arrives spread.

Its number, from 1, which is what removes it again.

Where it is, as file:line in the source you wrote.

The call's arguments, resolved to JSON values where the page could serialize them.

The rendered single-line text. Always present.

The page console type (log/warning/error/info/debug), or pageerror.

Writes to the error stream. Diagnostics that must survive a swallowed stdout go here too.

Writes to the primary stream — the TAP/spec/dot document itself.

Coverable lines across every file.

Covered lines across every file.

One entry per non-test source file the bundle mapped back to.

Overall percentage covered.

One built-in reporter by name, or false. An instance cannot cross a socket.

Several built-in reporters by name. Mutually exclusive with reporter, as it is locally.

One built-in reporter by name, or false. An instance cannot cross a socket.

Several built-in reporters by name. Mutually exclusive with reporter, as it is locally.

Lines the source map attributes to executable positions in the bundle.

Lines executed at least once.

Path relative to the project root, with forward slashes.

coveredLines / coverableLines, as a percentage rounded to two decimals.

Absolute path of the file it was declared in — used to apply that file's line targets.

"Module > Sub: test name" — the string a filter matches against.

1-based line of the declaration.

The QUnit module path it is declared under; empty for a top-level test.

The test's own name.

Its place on the stack: 0 is where the page stopped, and each one after it is the caller.

Whether the rest of the session is currently reading this one.

Where it is, the same way a pause names itself.

Directory to find the project root from. Defaults to process.cwd().

Project-relative path of the test file to write.

false when the file already existed and nothing was written.

Absolute path of the target file.

Directory to find the project root from. Defaults to process.cwd().

HTML fixtures to create, relative to the project root. Defaults to ['test/tests.html'].

Paths that already existed and were left alone.

Absolute paths of the files this call created.

info is a decision, warning a surprise, error a diagnostic that also hits stderr.

The text, already colored where the CLI colors it, with no # prefix and no newline.

Write message verbatim rather than as a # -prefixed comment. For pre-formatted blocks — the coverage table, a stack trace — whose own layout is the point.

Which of the run's two streams the default rendering goes to; output by default.

Whether the input worked. What output never says, and what a caller needs before it can do anything but print: colour the line red, decline to add it to the replayable history, exit non-zero on a piped session.

The input was unfinished (const a = {), so nothing ran and the terminal should read on.

The text to print, whichever way it went: the rendered value when the input worked, the error and its source-mapped stack when it did not. Empty when there is nothing to print.

Where the input stopped at a debugger statement, or absent when it ran to completion.

Tests QUnit ran because of this input. Already reported through the session's reporters.

The failure was the page throwing, rather than the session refusing the input.

Stops the page at file:line without a debugger statement in the source.

Whether there is still a page to evaluate in.

The call stack where the page is stopped, innermost first — empty when nothing is.

The breakpoints this session has set, in the order they were set.

Closes the page, the browser and the server. Idempotent.

What could come next after base: its own properties, or everything in scope at top level when base is ''.

Lets a paused page carry on. A no-op when it is not paused.

Where a value was written — the file and line of its declaration, or null for one that has no source: a value typed at this prompt, or anything that is not a function.

Evaluates one input in the page and resolves with what to print.

The source the breakpoint is in and the line it stopped on, or null when nothing is stopped.

Brings a file into the page after the fact, the way the command line brings one in before it.

What each preloaded file put in scope, and what kind of thing each one is.

Where to open Chrome's DevTools on the page this session is evaluating in — the same realm, the same DOM, the same paused frame. null where this browser has none to serve them from.

Stops whatever is executing in the page — the Ctrl-C of a runaway expression.

[file, exported names] per preloaded module — what the terminal lists on start-up.

What is in scope at the breakpoint, innermost first, or empty when the page is not paused. .locals, and the frame it reads is whichever ReplSession.selectFrame last chose.

Where the page is stopped at a debugger statement, or null when it is running.

What the input WOULD evaluate to, or '' where it cannot be known without doing something.

Loads a file again the way it was loaded the first time, for one that has changed on disk.

Reloads the page and brings the modules back, resolving with the names that returned.

Removes one by its number. false where there is no such breakpoint.

What this session has added to the page's globals — not the several hundred a browser starts with, which is a list nobody reads. .scope.

Reads the rest of the session in another frame of that stack, and says where it now is.

Resolves once nothing is in flight — a no-op at the back of the evaluation queue.

Runs one step and stops again, reporting where — or null if the page did not stop.

What an expression is worth in the page, as JSON — null where the page cannot say.

What TypeScript would call the value an expression comes to — structural, from the value.

Where the PAGE is served, e.g. http://localhost:1234 — the application, as a browser sees it.

Called when the page stops with nothing waiting on it — a breakpoint reached by a timer, or by anything else the prompt did not start.

Where a name came into this session from — the file it was imported from, or the input that declared it. null for a name the page already had, and for anything that is not a bare name.

Called for each console.* call and uncaught error from the page under test. Only warnings and errors arrive unless debug is on — the same selection the CLI prints.

Called for each of qunitx's own diagnostics — the # … lines about what it decided to run, what it could not find, what timed out. The default rendering has already gone to config.state.console; implement this only to capture them as data.

Called once when the run finishes, with the final counts on config.state.results.counter.

Called once before any test output. In watch mode, once per rerun.

Called once per test, after counter has already been updated for this test.

Where this reporter's text goes. silentConsole when the run was asked to print nothing.

The run's live outcome totals — the same object the runner updates, not a copy.

Whether this run is executing inside the persistent daemon.

--junit's value: true for the default path, a string for an explicit one.

Absolute path of the build output directory.

Absolute path of the directory holding package.json, for rendering paths relative to it.

Maps a bundle stack frame back to source, once the run has built one.

The engine the tests ran in.

Coverage artifact formats beyond the terminal summary.

File extensions treated as test files.

The active test-name filter, when one was set.

Absolute path of the build output directory — where the bundle and artifacts landed.

The port actually bound, which may differ from the one requested.

Absolute path of the directory holding package.json.

Wall-clock duration of the run in milliseconds.

Absolute paths of the test files this group bundled and ran together.

Position in the run's group list, and the group-<index> suffix on output.

Absolute path of this group's build output directory.

console.* calls and uncaught errors from the page — warnings and errors unless debug.

How many page-log entries were dropped to stay under the cap. 0 in every ordinary run.

Outcome totals.

Line coverage, or null when coverage was not requested.

Wall-clock duration of the test phase, in milliseconds.

What the CLI would have exited with: 0 when ok, 1 otherwise.

Absolute paths of the test files with at least one failure, attributed via source maps.

The subset of tests that failed — the list you almost always want first.

Absolute paths of the test files this run executed — the ones scoped to, in a filtered watch rerun, rather than everything being watched.

Epoch ms when it ended.

How the files were split across concurrent groups — one entry per group, never empty. groups.length is the concurrency the run actually used; 1 for watch and single-file runs.

The JUnit XML document, when junit was requested. Written to disk as well.

qunitx's own diagnostics for this run, in emission order.

true when every test passed and nothing else went wrong.

What the run resolved to — see ResolvedRun.

Epoch ms when the test phase began.

How the run finished: whether it got through everything it selected, and if not, what stopped it. Distinct from RunResult.ok, which is the verdict — a completed run can be entirely red, and an aborted one can have no failures at all.

Every finished test, in the order the browser reported them.

Test files in this run, or null when not known at announce time.

Concurrent groups the files were split across, or null alongside a null fileCount.

The name it is bound to.

The rendered value, coloured when the terminal takes colour.

Where it came from, or '' where nothing knows.

Browser engine. Defaults to chromium.

Where the script's own output goes, exactly as test and watch take one. Defaults to this process's stdout and stderr.

Directory the file, its relative imports and node_modules lookups resolve against.

Run in a visible browser window instead of headless.

Port the local server binds. Defaults to 1234, stepping over a taken one.

Ms the script may run before it is declared hung. Unbounded by default, like deno run.

Everything the script printed — its console calls and any uncaught error — in emit order, whatever console option was passed. The same shape a test run reports, capped the same way.

How many lines were dropped to stay under the cap. 0 when nothing was.

Wall-clock ms from the first bundle to the script's top level settling.

globalThis.exitCode if the script set one, 1 if it threw, else 0.

Absolute path of the file that ran.

True when the script finished with exit code 0.

The suite the file declared, or null when it was a plain script.

The script's export default, or undefined when it has none.

Why ScriptResult.value is undefined even though the script exported something, or null when there is nothing to explain — including when it exported nothing at all.

How many files were scanned.

The expression matched against, or undefined when everything was listed.

The tests the current selection matches, in declaration order.

Every listable test found, matched or not.

What the scan could not name, split by cause.

Line-target resolution warnings, in input order.

The value the assertion actually saw.

The value the assertion required.

The assertion's message, when one was given.

true when the assertion held.

Raw stack captured at the assertion, with frames pointing at the bundle.

true for assertions inside a todo test, which are expected to fail.

Present on failing tests only (QUnit trims the payload otherwise).

Module path followed by the test name, e.g. ['Math', 'adds'].

Test duration in milliseconds.

QUnit's outcome: passed | failed | skipped | todo.

The test's assertions. QUnit trims these for passing tests, so this is populated for failures and empty otherwise — a passing test's assertion count is not reported.

How long the test took, in milliseconds.

Source file this test was declared in, relative to the project root, or null.

"Module > Sub: test name" — the string filter matches against.

The QUnit module path it was declared under; empty for a top-level test.

The test's own name, without its modules.

QUnit's outcome for this test.

Cuts the run short. The browser drops the rest of its queue and the run ends where it is, with aborted: true on the result — which TestSession.result still resolves with, so an aborted run is answered rather than left hanging.

Closes the session, ending iteration. Idempotent; implied by await using.

How many events the feed dropped because a consumer fell behind. 0 in every ordinary run.

The same events as iterating the session, as a Stream — so the combinators are there without a Stream.from wrapper.

The finished run. Starts it if nothing has yet, and resolves with the same RunResult the final runEnd event carries — never undefined, which is the whole reason this is a session rather than a bare event stream.

Declarations whose name is computed at run time — test(`case ${index}`).

Files that parsed but declared no test the scan could see, e.g. via a local alias.

The three below, added up.

Files that could not be read or parsed at all.

Path to a module run after the tests; it receives the run's counters.

Path to a module run before the tests; it receives the resolved config.

Browser engine. Defaults to chromium, the only one that can collect coverage.

Run only files whose transitive imports changed since this git ref ('HEAD' for uncommitted).

Where the run's text goes. Defaults to the process streams when a reporter is NAMED, and to silentConsole otherwise — so a programmatic run prints nothing unless it was asked to.

Collect V8 line coverage (chromium only). formats additionally writes lcov/html artifacts.

Directory the project root and relative inputs resolve against. Defaults to process.cwd().

Forward every page console call and print the server URL.

File extensions treated as test files. Defaults to ['js', 'ts', 'jsx', 'tsx'].

Stop the run at the first failing test.

Run only tests whose "Module: test name" matches. QUnit's own semantics: case-insensitive substring, /regex/, /regex/i, or a leading ! to invert.

HTML fixture files to wrap the bundle in, relative to the project root.

Files, directories, globs, or file.ts#34 line targets — the same grammar as the command line's positional arguments. Defaults to package.json#qunitx.inputs.

Write a JUnit XML report. true writes <output>/junit.xml; a string is a path.

Run only the files that failed last time, from the persistent failure cache.

Open the output in a browser: true for the default, a string to name a binary.

Directory for the compiled bundle and HTML output. Defaults to 'tmp'.

esbuild plugins for the test bundle — live objects, not specifiers.

Port for the local test server. Defaults to 1234, incrementing on conflict.

Print the run with ONE reporter: a built-in name ('tap', 'spec', 'dot', 'github'), your own Reporter, or false. The same spelling as the CLI's --reporter.

Print the run with SEVERAL. Mutually exclusive with UserRunOptions.reporter: pass reporter for one, reporters for many, and validate rejects both at once.

Cancels the run when it fires.

Milliseconds a single test may take before the run is declared stalled. Defaults to 20000.

Cuts the current run short: the browser drops the rest of its queue and the run ends where it is, with aborted: true on its result.

Playwright's Browser for this session — unstable, playwright-core's type.

Stops watching, closes the browser and server, and ends the iteration. Idempotent.

How many events the feed dropped because a consumer fell behind. 0 unless something stalls.

esbuild's incremental BuildContext — unstable, esbuild's type.

The fine-grained feed: every event of every run, flat and in order, until the session closes.

The live fs.watch handles keyed by watched path — unstable, and a PARTIAL view: the parent-directory watchers, rescan intervals and symlink pollers the session also owns are not in here. It answers "what is being watched", not "every handle the watcher holds".

The initial run's result, available before anything has changed on disk.

The most recent run's result — initial until something re-runs.

The page the suite runs in — unstable, playwright-core's type.

Tears the session's machinery down and boots it again — browser, page, server, esbuild context and watchers — then runs the suite once, resolving with that run's result.

The coarse feed as a Stream: one complete RunResult per rerun, with the combinators attached. for await (const r of session) is the same sequence.

Re-runs now, optionally scoped to files, and resolves with that run's result.

Runs the whole suite, dropping any line-target selectors this session was scoped to.

Re-runs the files that last failed, or repeats the last run when nothing has failed yet — saying so as an info notice on the result rather than silently doing something else.

Whether a run is in flight right now.

Where the QUnit view is being served, e.g. http://localhost:1234.

The HTTP + WebSocket server serving the bundle — unstable, this project's own HTTPServer rather than a documented interface.

Renders a failure as the one-line message the CLI would print.

Narrows to a specific set of codes, for handling some failures and rethrowing the rest.

Narrows an unknown value to a declared failure. The guard to reach for after .result().

Path to a module run after the tests; it receives the run's counters.

Path to a module run before the tests; it receives the resolved config.

Browser engine. Defaults to chromium, the only one that can collect coverage.

Run only files whose transitive imports changed since this git ref ('HEAD' for uncommitted).

Where the run's text goes. Defaults to the process streams when a reporter is NAMED, and to silentConsole otherwise — so a programmatic run prints nothing unless it was asked to.

Collect V8 line coverage (chromium only). formats additionally writes lcov/html artifacts.

Directory the project root and relative inputs resolve against. Defaults to process.cwd().

Forward every page console call and print the server URL.

File extensions treated as test files. Defaults to ['js', 'ts', 'jsx', 'tsx'].

Stop the run at the first failing test.

Run only tests whose "Module: test name" matches. QUnit's own semantics: case-insensitive substring, /regex/, /regex/i, or a leading ! to invert.

HTML fixture files to wrap the bundle in, relative to the project root.

Files, directories, globs, or file.ts#34 line targets — the same grammar as the command line's positional arguments. Defaults to package.json#qunitx.inputs.

Write a JUnit XML report. true writes <output>/junit.xml; a string is a path.

Run only the files that failed last time, from the persistent failure cache.

Open the output in a browser: true for the default, a string to name a binary.

Directory for the compiled bundle and HTML output. Defaults to 'tmp'.

esbuild plugins for the test bundle — live objects, not specifiers.

Port for the local test server. Defaults to 1234, incrementing on conflict.

Print the run with ONE reporter: a built-in name ('tap', 'spec', 'dot', 'github'), your own Reporter, or false. The same spelling as the CLI's --reporter.

Print the run with SEVERAL. Mutually exclusive with UserRunOptions.reporter: pass reporter for one, reporters for many, and validate rejects both at once.

Cancels the run when it fires.

Milliseconds a single test may take before the run is declared stalled. Defaults to 20000.

The most recent page console calls and uncaught errors, capped at MAX_BROWSER_LOGS.

How many page-log entries the cap dropped.

Every diagnostic, in emission order.

Records one page console call or uncaught error.

Records one diagnostic.

Records one finished test.

Drops everything from a previous run. Watch sessions reuse one collector across reruns, so this is what keeps rerun N's result from containing rerun N-1's tests.

Every finished test, in arrival order.

Browser engine. Defaults to chromium.

Where the script's own output goes, exactly as test and watch take one. Defaults to this process's stdout and stderr.

Directory the file, its relative imports and node_modules lookups resolve against.

Run in a visible browser window instead of headless.

Port the local server binds. Defaults to 1234, stepping over a taken one.

Ms the script may run before it is declared hung. Unbounded by default, like deno run.

Everything the script printed — its console calls and any uncaught error — in emit order, whatever console option was passed. The same shape a test run reports, capped the same way.

How many lines were dropped to stay under the cap. 0 when nothing was.

Wall-clock ms from the first bundle to the script's top level settling.

globalThis.exitCode if the script set one, 1 if it threw, else 0.

Absolute path of the file that ran.

True when the script finished with exit code 0.

The suite the file declared, or null when it was a plain script.

The script's export default, or undefined when it has none.

Why ScriptResult.value is undefined even though the script exported something, or null when there is nothing to explain — including when it exported nothing at all.

Absolute path of the file it was declared in — used to apply that file's line targets.

"Module > Sub: test name" — the string a filter matches against.

1-based line of the declaration.

The QUnit module path it is declared under; empty for a top-level test.

The test's own name.

How many files were scanned.

The expression matched against, or undefined when everything was listed.

The tests the current selection matches, in declaration order.

Every listable test found, matched or not.

What the scan could not name, split by cause.

Line-target resolution warnings, in input order.

Declarations whose name is computed at run time — test(`case ${index}`).

Files that parsed but declared no test the scan could see, e.g. via a local alias.

The three below, added up.

Files that could not be read or parsed at all.

Cuts the run short. The browser drops the rest of its queue and the run ends where it is, with aborted: true on the result — which TestSession.result still resolves with, so an aborted run is answered rather than left hanging.

Closes the session, ending iteration. Idempotent; implied by await using.

How many events the feed dropped because a consumer fell behind. 0 in every ordinary run.

The same events as iterating the session, as a Stream — so the combinators are there without a Stream.from wrapper.

The finished run. Starts it if nothing has yet, and resolves with the same RunResult the final runEnd event carries — never undefined, which is the whole reason this is a session rather than a bare event stream.

Coverable lines across every file.

Covered lines across every file.

One entry per non-test source file the bundle mapped back to.

Overall percentage covered.

Lines the source map attributes to executable positions in the bundle.

Lines executed at least once.

Path relative to the project root, with forward slashes.

coveredLines / coverableLines, as a percentage rounded to two decimals.

The engine the tests ran in.

Coverage artifact formats beyond the terminal summary.

File extensions treated as test files.

The active test-name filter, when one was set.

Absolute path of the build output directory — where the bundle and artifacts landed.

The port actually bound, which may differ from the one requested.

Absolute path of the directory holding package.json.

Absolute paths of the test files this group bundled and ran together.

Position in the run's group list, and the group-<index> suffix on output.

Absolute path of this group's build output directory.

console.* calls and uncaught errors from the page — warnings and errors unless debug.

How many page-log entries were dropped to stay under the cap. 0 in every ordinary run.

Outcome totals.

Line coverage, or null when coverage was not requested.

Wall-clock duration of the test phase, in milliseconds.

What the CLI would have exited with: 0 when ok, 1 otherwise.

Absolute paths of the test files with at least one failure, attributed via source maps.

The subset of tests that failed — the list you almost always want first.

Absolute paths of the test files this run executed — the ones scoped to, in a filtered watch rerun, rather than everything being watched.

Epoch ms when it ended.

How the files were split across concurrent groups — one entry per group, never empty. groups.length is the concurrency the run actually used; 1 for watch and single-file runs.

The JUnit XML document, when junit was requested. Written to disk as well.

qunitx's own diagnostics for this run, in emission order.

true when every test passed and nothing else went wrong.

What the run resolved to — see ResolvedRun.

Epoch ms when the test phase began.

How the run finished: whether it got through everything it selected, and if not, what stopped it. Distinct from RunResult.ok, which is the verdict — a completed run can be entirely red, and an aborted one can have no failures at all.

Every finished test, in the order the browser reported them.

The test's assertions. QUnit trims these for passing tests, so this is populated for failures and empty otherwise — a passing test's assertion count is not reported.

How long the test took, in milliseconds.

Source file this test was declared in, relative to the project root, or null.

"Module > Sub: test name" — the string filter matches against.

The QUnit module path it was declared under; empty for a top-level test.

The test's own name, without its modules.

QUnit's outcome for this test.

Cuts the current run short: the browser drops the rest of its queue and the run ends where it is, with aborted: true on its result.

Playwright's Browser for this session — unstable, playwright-core's type.

Stops watching, closes the browser and server, and ends the iteration. Idempotent.

How many events the feed dropped because a consumer fell behind. 0 unless something stalls.

esbuild's incremental BuildContext — unstable, esbuild's type.

The fine-grained feed: every event of every run, flat and in order, until the session closes.