api #

One library's bar: a number with its length and ratio, or the reason there is none.

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.

The stages a cell runs, in display order.

Whether a results file holds any timed number.

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 size tiers of an input, smallest first.

Where an input came from, the primary set first and the stress inputs last.

The sources whose inputs may be written for this benchmark, with no upstream file.

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.

Every compression, in display order.

Both views, with their labels, in display order.

Which size of a bundle to show: the minified bytes, or those bytes compressed.

What the bundle tables show.

Which bundle table to show: what each language costs, or each set's total.

The cells of one language from one source.

Which cells to show.

Sets of several languages that hold the same ones, shown as one row.

Whether a library's coverage claims a language.

How one library covers one language.

A coverage matrix: a row of cells by library id for each language, and the footnotes.

Reads a selection from a query. Ids come back in the order of options, each once.

The form of a cold start selected by default: the chunk whose size is reported.

The measure shown by default: the sum, which is what is ranked.

How the HTML's size is shown by default: raw, as the output table has always shown it.

The set summed by default, when the file has it: what a documentation site imports.

The source selected by default: the primary set, which no measured library authored.

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

The docs data, set by the docs layout from its load and read by the tomes.

The parts of the rendered results file that the docs pages show.

The query that restores a selection. Only what differs from the defaults is written, so the default view has an empty query. A list is its ids joined by commas, and an empty list is an empty value.

The name of each engine kind.

The set with no language: a library's runtime floor.

The path of the first place two JSON values differ, or null when they are equal. Object keys are compared as sets, so their order doesn't matter.

What differs between a published run and the deterministic results in the things a deterministic number depends on: each library's version with its extra packages, the versions of its dependencies (its install closure), the corpus, and what built and compressed the bundles (BenchBundler), when both files hold bundle sizes.

The set holding one language alone.

The bare Node baseline of a results file, or null when it measured no cold start.

The set of every timed language, which every library claims.

The set of every timed language but one.

A byte count in decimal units, where 1 kB is 1,000 bytes. A negative count keeps its sign, since a difference between two sizes can be one.

The label of a cell group: its language and its source.

A count with thousands separators.

The UTC date of an ISO timestamp, as YYYY-MM-DD.

A commit or content hash shortened for display, keeping a -dirty marker.

The name of an engine kind or an output shape, or the id for one it doesn't know.

A row's number as text, in the row's unit.

A duration given in milliseconds.

A duration given in nanoseconds, in the unit that keeps it readable.

A fraction as a percentage: 0.033 is 3.3%.

An upstream file as owner/repo@commit, the commit shortened.

A ratio as a factor: 1.00×, 12.3×, 140×.

A number to about three significant digits: two decimals under 10, one under 100, and a whole count from there.

A source key's label: the source, naming the owner of a home input.

What a source key's inputs are, naming whose samples a home input is.

The selected cells in groups of one language and one source, in roster and source order. Within a group the cells are ordered by size, then file, then mode.

The inputs in groups of one source, in source order, each ordered by file.

How many characters of a hash the site prints.

The compression the headline bundle sizes are shown in.

A headline figure drawn as bars, with what its heading says.

Every measure, in display order, with its label and whether its rows are compared.

What moved says when the retained heaps differ beyond a reading's jitter.

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

Two retained-heap readings (BenchHeap), in KiB, are the same reading when they are this close, or HEAP_TOLERANCE_RATIO of the larger, whichever is larger. Readings agree to well under a kibibyte; the margin keeps a reading from being the one number of the deterministic file that fails a check on an unchanged tree.

The relative margin of HEAP_TOLERANCE_KB.

A number of a retained heap, or the three summed.

The inputs of one source.

The numbers of an install footprint, with their labels and units, in display order.