results_schema.ts

The anchor drift under which a run counts as stable; 0.03 is 3%. Past it the machine changed state during the run, and the ratios between libraries in a cell are more trustworthy than any absolute time.

Whether two heap entries are the same reading, each number within heap_readings_agree.

Whether two heap sections hold the same readings, each within heap_readings_agree.

Lists what a results file lacks to be a complete run, from the file alone:

• in every cell, every library of the roster that claims the cell's language has a number or an entry in meta.excluded. The number is a timed value, or for a deterministic-only file the one the cell states: its token count on a tokenize cell, its output size on an html cell
• every listed input of a timed language that some library claims has a cell in every mode the file's cells use

It can't tell that an input is missing altogether, or a whole mode: the inputs roster lists what was measured, only meta.corpus_hash names the corpus it came from, and the modes are taken from the cells so that a file stays valid when the harness gains a mode.

Lists the cold-start scenarios a results file lacks to be a complete run, from the file alone. Each of these has an entry in startup or in meta.startup_excluded:

• the bare baseline
• for every library of the roster, unbundled and bundled: core, then lang and first_highlight for every timed language it claims, then set for every feature set the file's cold start names, where the library claims every language of it

A scenario over a language or a set the library doesn't claim is unsupported, and is no gap. The sets are taken from the file, since the schema doesn't say which sets a harness starts cold. So one thing the file can't show: with every set entry removed it names no set, and still reads as complete.

Whether a run's numbers can be published as results: a complete full run with no gap in its cells or its cold start (bench_results_find_gaps, bench_results_find_startup_gaps), from a commit that records everything that ran, on a machine that held still and was calibrated, so the run carries a noise floor that says which differences are results. A run that was stopped and resumed qualifies like any other: its anchor covers every segment. A site shows anything else as what it is, never as a result.

Whether a run set out to cover everything: every library on every cell, and for a full run in every cold-start scenario, measured for real. A smoke run never did, and neither did a run with any filter. Whether the file then holds everything is bench_results_find_gaps and bench_results_find_startup_gaps.

The reference workload measured at the start and end of a run, and of every segment of a run that was stopped and resumed. Its drift says whether the machine changed state while the run was in progress.

One library's result for one feature set: its sizes, or why there are none. An entry with an unsupported key is read as the latter and anything else as sizes, so a malformed entry is reported against the shape it was meant to be.

What the bundle sizes were built and compressed with. Together with the libraries' versions it is what the sizes depend on, apart from the zlib and brotli inside the Node that compressed them. The compression levels are also the ones the HTML's compressed sizes (BenchCell.compressed) are taken at. It names exactly one of rolldown and rollup, and is reported against the shape it names, so a malformed one never reads as a bare "Invalid input".

What bundles from Vite 8 on: Vite with the Rolldown inside it.

What bundled up to Vite 7, which files measured then record: Vite with the Rollup inside it.

The bundled size of one library over one feature set: raw, gzip, and brotli are the minified JS, and what else a page loads for the library has a section of its own. Deterministic.

A feature set a library can't be measured over, naming the languages it lacks.

Some bytes a page loads, measured raw and compressed. Deterministic.

One input measured in one mode, across libraries. A library absent from values, tokens, and output was not measured here: it is unsupported, excluded, or outside the run's filters.

Each deterministic number is stated once for an input, on the cell whose call returns it: tokens on the tokenize cell, since it counts what tokenize returned, and output on the html cell. The other is empty there.

The size of one library's HTML for a cell's input once compressed, at the levels BenchBundler records: what a server sends for a page that renders the highlighted input. Its raw size is BenchCellOutput.html_bytes. Deterministic.

The size of one library's HTML for a cell's input. Deterministic.

One library's timing and memory in one cell. Machine-dependent.

A color scheme a theme covers.

How a library supports a language it claims: true for directly, or a footnote for anything a reader should know, like a third-party grammar.

How a library lexes. A filterable tag, not a ranking.

A library that claims a cell's language but failed the pre-measurement output check there, so it was not measured. Distinct from unsupported, which is a language missing from the library's coverage.

What a library holds once one language is loaded and highlighted once, over a bare Node process: its single:<lang> bundle imported, the language's harness snippet highlighted, and garbage collected until the heap settles. That is after one highlight of a small snippet; larger inputs leave more, most of all for regexp and wasm engines. Deterministic for a Node version and platform (the one the check workflow pins, on x64), within heap_readings_agree.

One input of the corpus: a file, what it is, and where it came from. The corpus manifest is a list of these, and a results file carries the ones its cells measured.

What npm install of a library adds: the runtime dependency closure of its package and its extra packages, each package counted once, as this repository's lockfile installs them. Deterministic.

One language id of the run, as the harness declares it in bench/langs.ts.

One measured library. The roster of these drives every page of the site.

The machine a run's timed numbers came from.

Where, when, and from what a run was produced. generated_at, machine, node, and commit say where timed numbers came from, and are null only in a file that has none: its numbers are the same on any machine, at any time, and a commit can't name the tree it is itself committed in.

What a cell measures.

The stage a cell runs: tokens out, or the HTML string consumers ship.

The machine's noise floor, from a calibration run: every library is measured as two, in separate processes, which should come out equal. A difference smaller than this is not a result.

What a library's html output carries its colors in.

How far apart a run's own processes came out: an A/A figure from the run itself. Each library on each cell was measured by several processes, which should agree, and every pair of them gives a deviation. It is fuz_util's StatsPairwiseDeviation, restated here so the schema depends on zod alone.

One file an input came from, pinned so the input can be rebuilt and checked.

One run of the benchmark. Beyond each section's shape, parsing checks that the sections agree: ids are unique and refer to roster entries, every cell describes its input as the inputs roster does and is named after it, no library has numbers for a language it doesn't claim or a cell it was excluded from, no cell covers an untimed language, a run with timed numbers has an anchor, its run parameters, and where it came from, a run with no filters has no gap (bench_results_find_gaps, and for a full run bench_results_find_startup_gaps), each deterministic number of an input is stated on one cell, and bundle sizes cover every library and set or none, as the install footprints cover every library and the compressed HTML sizes every library with an HTML size.

The parts of a results file that say whether it has a gap.

Something a results file lacks that a complete run would have, and where.

The parts of a results file that say whether its cold start has a gap.

How the timed numbers of a run were measured: its cells and its cold-start scenarios. It tells a complete full run from a smoke, calibration, or partial run: see bench_results_is_publishable.

The filters a run was restricted by. Each is null when the run was not restricted on that axis. libraries and langs narrow the cells and the cold-start scenarios alike; sizes, modes, and sources select inputs, so they narrow the cells only.

What a run is: full measures with the published parameters, smoke runs every cell once to prove the harness works and its numbers mean nothing, and calibrate measures every library twice in every cell to find the noise floor.

A machine-dependent measurement a run makes: throughput is the timed cells, and startup is cold start.

A named list of languages that bundle size is measured over.

An input's size tier, by real file size.

Who an input came from: neutral is real code no measured library authored, shiki is Shiki's upstream benchmark samples, home is one library's own samples, and harness is a snippet written for this benchmark.

One cold-start measurement. Each sample is a fresh Node process that does the scenario's work and nothing else, and its time is the process's own clock when the work is done, which counts from the start of the process. So every time includes Node starting up, and the bare entry is that part alone. Machine-dependent.

A cold-start scenario a library was not sampled in: its first process there failed to import, exported nothing, or highlighted with too few kinds of span. Distinct from unsupported, which is a scenario whose languages the library doesn't claim, and which has no entry anywhere.

What tells one cold-start scenario from another.

What a cold-start sample does before it stops the clock: bare is Node alone, core imports a library with no language, lang imports it with one language, set imports it with a feature set's languages, and first_highlight imports it with one language and highlights once.

The facts of a run that decide whether it is publishable, as one line for an error.

Whether two heap readings, in KiB, are the same reading: within HEAP_TOLERANCE_KB, or HEAP_TOLERANCE_RATIO of the larger, whichever is larger.

Parses a results file, with every problem in one readable message.

The id of a cell: its input's file and its mode, which together are unique in a run.

The string a cold-start scenario is told apart by.

The most a compressed size may exceed the raw one by: a compression format adds a header and a little framing, so a few bytes of input, or bytes that don't compress, come out slightly larger. Anything past that is a mistake.