Watching a page for changes

diwall-watch answers one question: has this page changed since last time?

It saves a reference image, compares the current state against it, and returns a verdict. Useful after a deployment, on a page you do not control, or on anything you would otherwise check by eye every morning.

Save a reference, then compare

# Once — record what "normal" looks like
diwall-watch --url https://target.local/ --sauver-reference --guide-version 1.3

# Afterwards — as often as you like
diwall-watch --url https://target.local/ \
  --comparer-pixel /opt/diwall/references/target.local/reference.png \
  --guide-version 1.3

The comparison is arithmetic: a proportion of differing pixels, and a verdict. No model, no interpretation, no network beyond the page itself. The same input always gives the same answer — which is what makes it usable in a check you run unattended.

The part that surprises everyone

Two captures of an unchanged page are not identical.

Rendering is not perfectly deterministic. Sub-pixel antialiasing, font hinting, a hairline of scrollbar — two renders taken seconds apart on a page nobody touched can differ by around 0.19 % of pixels.

That is the floor. Any threshold below it reports changes that did not happen; any real change smaller than it hides in the noise. Both failure modes are silent, which is why it is worth knowing before you trust a verdict.

--seuil-bruit 0.2      # below this, treat as noise
--seuil-stable 0.5     # above this, call it a change

Exclude what is supposed to move

A dashboard with live counters, a timestamp in the corner, a rotating banner — these change every second by design. Comparing them wholesale means either constant false alarms, or a threshold so high it hides everything else.

diwall-watch --url https://target.local/ \
  --comparer-pixel reference.png \
  --exclure-zone 0,0,400,80 \
  --guide-version 1.3

Exclude the region that is meant to change, and the rest of the page becomes watchable at a strict threshold. This was learned the hard way: a dashboard comparison once returned stable at 0.19 % while genuinely differing, because the live area absorbed the entire budget.

Several views of the same page

diwall-watch --url https://target.local/ --sauver-reference \
  --nom dashboard --guide-version 1.3

--nom keeps distinct references for the same URL — logged out and logged in, before and after a deployment, desktop and narrow. Without it, each new reference overwrites the last.

Watching a page behind a login

--sauver-reference performs its own capture, and that capture is not authenticated. For a protected page, produce the image with a scenario that logs in, then hand it over:

diwall-rpa --scenario login-dashboard.json --guide-version 1.3
diwall-watch --url https://target.local/dashboard \
  --capture /tmp/diwall/…/capture_….png --sauver-reference \
  --nom dashboard --guide-version 1.3

--capture takes an existing PNG instead of taking one. Same for the comparison side — capture through the scenario, compare with --capture.

Structure instead of pixels

If what you care about is that the page still works rather than still looks the same, compare structure:

diwall-monitor-verifier --scenario page.json --reference page.ref.json

It compares the HTTP status, DOM statistics and the results of evaluer assertions against a saved reference — no pixels, no vision model, immune to a font update. Different question, different tool, and often the better one for an unattended check.

In short

• Save a reference, compare against it, read the verdict.
• Renders differ by ~0.19 % on an unchanged page — that is your noise floor.
• --exclure-zone for anything designed to move.
• --nom for several views of one URL.
• --capture to watch a page behind a login.
• Structural comparison when appearance is not the point.