Proving ground

Twelve vectors, all of them real. Each control performs the actual operation on this live page — nothing is intercepted, sandboxed, or replayed from a recording. The immune system finds out the same way it would find out about you.

Where a defence is partial, the card says so before you press it. An injected inline script executes once before it can be removed. A disabled stylesheet is caught on a sweep, not instantly. An exception is witnessed, not undone. Those gaps are stated because a demonstration that hides them is a magic trick.

Containment zone

Specimen 01 — a protected heading

Four nodes in this panel carry integrity snapshots: this paragraph, the heading above it, the link below, and the plate to the right. Fire anything from the vectors on this page, or edit them by hand in devtools.

A protected link → /anatomy

Specimen plate: concentric rings on a technical grid

Vectors — twelve, all real

Excise a node

heading.remove()

Removes the specimen heading from the document. The guard re-inserts the original node object at its recorded position, so listeners and state survive.

Rewrite the text

para.textContent = "…"

Replaces the paragraph's contents. Restored from the innerHTML captured when the node was first protected.

Strip the classes

para.className = ""

Removes every class from the paragraph, which in a Tailwind build strips its entire appearance. The class attribute is restored from the snapshot.

Hijack a link

link.href = "https://…"

Repoints the specimen link at another origin — the shape of a real phishing rewrite. The attribute is restored to its boot value.

Inject a script

body.appendChild(script)

Appends an inline script that increments a counter on window. Aether ejects the element and records it.

An inline script executes the instant it is appended, and MutationObserver delivers on a microtask — so this runs once before removal. Removal is containment. Prevention is the CSP header's job, not JavaScript's.

Inject an iframe

body.appendChild(iframe)

Appends a cross-origin iframe. The element is ejected on detection.

Two layers act here. `frame-src 'none'` in the policy stops it loading at all; Aether removes the element afterwards. The header is doing the heavier work and it would be dishonest to claim otherwise.

Disable a stylesheet

sheet.disabled = true

Turns off the site's own stylesheet. The page loses its appearance until the guard's idle sweep finds it and switches it back on.

`disabled` is a property, not an attribute — no MutationObserver reports it. This is caught by the sweep, so expect up to two seconds of unstyled page. That gap is real and worth seeing.

Break the image

img.src = "/missing.svg"

Points the specimen plate at a path that does not exist. The reflex re-fetches the source recorded at boot with the cache bypassed, and the plate comes back.

Break it beyond repair

// the recorded source is gone too

The same failure, but with no good source to fall back on. Watch the reflex spend its three attempts and the breaker open — the element is marked contained rather than retried forever.

This is what failure looks like. A self-healing system that cannot admit defeat is a busy loop with better marketing.

Throw an exception

setTimeout(() => { throw … })

Raises an uncaught error. It is captured and sealed into the ledger with its origin.

Recorded as observed, not healed. The throw already happened and whatever it interrupted stayed interrupted — catching an exception at the top level is witnessing it, not undoing it.

Reject a promise

Promise.reject(new Error(…))

Produces an unhandled rejection, captured by the same feed as thrown errors.

Flood the main thread

while (performance.now() < end) {}

Blocks the thread in four 420ms bursts. Watch the lag trace climb past the threshold, the organism start shedding load, the cell population thin — then recover on its own.

Each burst is deliberately longer than the 250ms sample interval. An earlier version used 200ms bursts and the flood registered as a healthy thread — the samples kept landing in the gaps between them. This is genuine main-thread pressure, which is still not a network flood; see Limits.