Bring us a failure we don’t have

const box = v.getBoundingClientRect();
const painted = box.width > 0 && box.height > 0 &&
                getComputedStyle(v).visibility === 'visible';
console.assert(painted);   // PASSES on a film never fetched

// and its most seductive form, a screenshot diff:
//   await expect(hero).toHaveScreenshot('hero.png');
// The poster IS the first frame. The snapshot matches perfectly.

The rectangle is painted by something that cannot know whether the film arrived.

let asked = false;
v.addEventListener('loadstart', () => { asked = true; });
setTimeout(() => {
  console.assert(asked, 'FILM NEVER REQUESTED');
  console.assert(v.networkState !== 0, 'NETWORK_EMPTY');
}, 900);

// better, out of page: count the bytes, not the intentions
//   page.on('request', r => { if (/\.mp4$/.test(r.url())) hits++ });
//   expect(hits).toBeGreaterThan(0);

Measured 23 August 2026: simulated 3g, downlink 0.9 and Data Saver each produced zero network requests for the film.

console.assert(getComputedStyle(v).opacity === '1');
console.assert(v.classList.contains('playing'));
console.assert(v.getAttribute('src'));
// All three PASS on a clip whose play() rejected 1.5s ago.

None of those values is produced by a path that includes playback succeeding.

const t0 = v.currentTime;
await new Promise(r => setTimeout(r, 800));
console.assert(v.readyState >= 3, 'HAVE_FUTURE_DATA never reached');
console.assert(v.currentTime > t0, 'time did not advance');
console.assert(!v.error, 'media error ' + (v.error && v.error.code));

readyState 0, currentTime 0, error code 4 — while opacity still reads 1.

let errs = 0;
window.addEventListener('error', () => errs++);
window.addEventListener('unhandledrejection', () => errs++);
console.assert(errs === 0, 'page threw');    // PASSES

The silence of a function that returned on its first line is identical to the silence of one that ran to completion.

const items = document.querySelectorAll('.item');
console.assert(items.length > 0, 'nothing to act on — stale selector');
console.assert([...items].every(el => el.dataset.ready === '1'),
               'feature no-opped');

// the general form: every effectful pass declares how many things it
// expected to touch, and fails when that number is zero.

Three items in the document, zero touched, error count still 0.

ffprobe -v error -select_streams v:0 \
  -show_entries stream=level -of csv=p=0 clip.mp4
# -> 31   "good, Level 3.1 as intended"

# and its accomplice, the quiet pipeline:
ffmpeg -v error -i in.mp4 -c:v libx264 -level 3.1 out.mp4 && echo OK
# exit 0. libx264 DID print the violation, at warning level,
# and -v error threw it away.

The field reads 31 because somebody wrote 31, not because the stream honours it.

mbs=$(( ((w+15)/16) * ((h+15)/16) ))     # CEIL, not floor
rate=$(( mbs * fps ))
[ "$mbs" -le 3600 ] && [ "$rate" -le 108000 ] \
  && echo "PASS: the declaration is true" \
  || echo "FAIL: declares L$lvl, carries $mbs MB @ $rate MB/s"

Prints the two real numbers beside the two ceilings — the same sentence libx264 printed at encode time and nobody read.

const ok = !!video.currentSrc;               // a string exists
await page.waitForSelector('video[src]');    // an attribute exists

Neither ever asks a decoder for a picture.

// 1. prove the instrument can register a difference AT ALL, first
if (!v.canPlayType('video/mp4; codecs="avc1.4D401F"'))
  throw new Error('INCONCLUSIVE: this harness is blind');

// 2. only now assert on decoded output
// (and accumulate FORWARD motion — a loop that wraps
//  makes a naive t1-t0 delta go negative)

Where the codec is genuinely absent it exits inconclusive rather than returning a green tick it has not earned.

live_len = int(r.headers['Content-Length'])
if live_len == os.path.getsize(local):
    print('IDENTICAL')     # <- the only branch that ever ran

Byte count is invariant under the entire class of edits this check existed to catch. It had one reachable state, and it printed it.

It was worse than that: it only behaved because Python’s urllib requests identity encoding by default. Negotiate gzip and the same check flips to reporting every file as different — and a check that always fails gets muted, which is the same ceremony wearing the opposite mask.

lh = hashlib.md5(open(local,'rb').read()).hexdigest()
if hashlib.md5(body).hexdigest() != lh:
    print(f'DIFFERS {rel}  local {lh[:8]} / live {...}')

Two visibly different digests and the file that carries them.

// what a reviewer actually checked, by eye and then in a test:
await page.waitForFunction(() => countEl.textContent === '');
// 8,7,6,5,4,3,2,1 then blank. Every frame correct.

This is the sharpest one. The observable is not merely uncorrelated with the outcome — it is the trigger of the outcome’s destruction. The better the countdown looks, the more certainly the advance is dead. A display cannot report the failure of a thing it causes.

if(left<=0){ clearInterval(tick); tick=null; }   // stop only the ticker

// and the test that can fail:
const before = video.currentSrc;
await page.waitForFunction(s => video.currentSrc !== s, before,
                           { timeout: 12000 });

A timeout naming the source that never changed. The countdown’s appearance is not consulted at all.

u = u.split('#')[0]          # <- the evidence is deleted here
if not os.path.exists(resolve(u)):
    missing.append(u)

The check discards the evidence, then reports it found none. Both a good fragment and a dead one leave behind the identical path string.

def ids_of(text):
    return set(re.findall(r'\bid="([^"]+)"', text))

if frag not in ids_of(src[target]):
    missing.append((rel, href, f'no id="{frag}" in {target}'))

The page, the href, and the reason: no id="if-someone-calls" in findings/index.html. Exit 1, so the deploy stops.

curl -s https://example.org/ | grep -c 'the wrong sentence'   # expect 0

The check interrogates the one copy the publisher can write to — which is, by construction, the copy that was just corrected. Its scope is exactly the set in which it can never find a failure. It feels like the strongest possible check, because it tests production directly and tests the exact string. Directness is the disguise.

# enumerate CARRIERS, not sources.
for every superseded string:
    scan every artefact you can read
# then LIST, separately, every artefact you CANNOT read —
# because that list is the actual finding.

The path of every file still carrying a retired sentence. Plus an honest count of the artefacts grep can say nothing about: frames, waveforms, screenshots, rasters. Those close by retirement, never by correction.

// read the authored stylesheet
[...sheet.cssRules].find(r => r.selectorText === ':root')
  .style.getPropertyValue('--ink')   // '#0b171e' -> PASS

A later rule of equal specificity does not edit the earlier one — it out-ranks it. The earlier declaration survives verbatim, so a check reading authored CSS returns the right answer from a healthy document and a poisoned one alike.

// read what the browser RESOLVED, and convict on a redefined NAME
const cs = getComputedStyle(document.documentElement);
for (const [name, authored] of SITE_TOKENS)
  if (cs.getPropertyValue(name).trim() !== authored)
    fail(`${name}: authored ${authored}, resolved ${...}`);
// and FAIL on any stylesheet you could not read —
// a sheet you cannot read is not a sheet that passed.

Every redefined token by name, with the value it lost.