What a green count does not prove

A build does not ship because it compiled. It is launched, pointed at a page of our own, and asked the questions a site asks a visitor.

Each answer is one reading. Some are set against what the profile claims and some only ask a number to stay still, and the run ends in a count with one word that decides whether the build moves.

The readings are not the whole run. The version and the name of the build are read from the outside too: a build answering correctly under somebody else's name is not ours to ship.

1. 1

   Launches the build

   The engine starts on a profile with a template and an exit country.

2. 2

   Asks from inside

   Screen, languages, time zone, graphics, devices and the rest are read on a page.

3. 3

   Names a verdict

   One word is printed beside the count for anything reading this from a script.

A reading that asks whether a number is stable is answered the same way by a browser with nothing changed in it. Stability is a property of arithmetic and comes free.

The audio reading shows this plainly. A short tone is rendered with the speakers off and the samples are summed, and the reading asks only that the sum is finite, is not zero, and comes back the same twice.

A reading with force behind it sets an answer against something outside itself. Readings held against what the profile claims are built that way; readings asking a number merely to sit still compare it with nothing.

The noise a profile carries is derived from the identifier of that profile. Two profiles of one build therefore have to answer with two different numbers.

So the run opens the same page twice, once in each of two profiles, and reads the canvas and the audio out of both. Numbers that agree mean the noise is not reaching the page, and the run says exactly that.

1. 1

   Draws two profiles

   Two identifiers, one build, one template.

2. 2

   Reads the same pair

   The canvas hash and the audio sum out of each of them.

3. 3

   Requires a difference

   Agreement is reported as noise that is not being applied.

The seed of a profile is fixed by the template, the identifier, the exit country and the generation it was made under. A value the seed dictates has to come back byte for byte the same on macOS and on Windows.

So one run can be set against a run of the same profile on the other system. A reading that passes on one system and fails on the other is a difference neither run can show alone.

• Some values differ by right

  The byte length of a drawn canvas and which decoy fonts exist on that system at all.

• A reading the other run has and this one lacks

  That is a difference the comparison refuses to pass over.

A run that found nothing wrong is not the same as a run that proved something. Those are two different states and they carry two different names.

Only the accepting verdict lets a build move. The other two leave the run the same way, so a proof that was skipped cannot be mistaken for a proof that was made.

The word itself is printed on the last line in plain letters, so nothing has to guess from a number what happened. A run that proved nothing says so in that word.

Open two profiles of the same browser and load one page that draws a canvas and sums a tone. Read the pair of numbers in each profile and set them side by side.

Different numbers mean the noise follows the profile in front of you. Identical numbers mean the page is reading the machine underneath it.

That second outcome is the one a count of passing readings will never show you. It takes two profiles to make it visible at all.