Evidence Hub
Every R50 run leaves an auditable evidence package: score pair, changed files, rollback manifest, manifest and checksums. This page explains each file and how to verify it.
SAMPLE OUTPUT
A sample executive report — from a real run
We prepared this from the engine's (0.8.1) run over this site's LIVE version on 25 October 2026; every figure on this page comes from that run's records. The run analysed 58 HTML documents in detail and measured 10 of them in a real browser as well; it returned 97/100. Scored open work items: 1 — a real decision document. Measurement is partial: 96.2% of the checks could be measured; the rest stay explicitly unknown in the report. Findings and the roadmap vary by site — this sample shows the format. The executive brief is one page; technical depth moves to the annexes.
- Executive brief: outcome, scope, priorities and a 0-7 / 8-30 / 31-90 day roadmap
- Number provenance: every figure ties back to run records (REPORT_MANIFEST + METRIC_LINEAGE)
- Delivery formats: DOCX + PDF + a machine-readable evidence pack
Download the sample report (Markdown, Turkish)
Sharing scope: The "GİZLİ VE ÖZEL" (confidential and private) mark in the corner of the image is the template's default class for client deliveries — we never publish client reports. This sample is the single exception: the site under review is WebTrustEngine's own, and its owner decided to publish it.
The score is not a guarantee or a live pass; it exists to track progress across rescans with the same method.

AUTHORITATIVE REPORT
When does a document count as an authoritative WTE report?
The Markdown sample downloaded from the section above is an editorial summary prepared from a run; it is not the authoritative (native) engine report itself. The cover image beside it is taken from that run's native PDF report. The engine's working contract sets a single threshold: only the engine's own scan and reporting flows produce its native Word and PDF reports.
We present a document as an authoritative WTE report only when two conditions hold together. First: the document must be recorded in the same run's REPORT_MANIFEST.json as a Word or PDF item, with its canonical path, its byte size and its SHA-256 digest. Second: the package's read-only integrity verification must pass. Documents produced by a custom script, an office library or any other tool are auxiliary documents.
Before delivery we verify three conditions together: the manifest record, the quality gate and the read-only integrity verification. If one of the three fails, we do not present the document as authoritative. The SHA-256 verification on this page is a separate application of the same discipline: it runs against the CHECKSUMS file in your delivery package.
The order of the results
The order in which results are narrated is fixed: site assessment, measurement status and risk acceptance first; scope and package-integrity results after them. Package integrity shows only that the report's own files are intact; it does not show the state of the site under review.
What the evidence package contains
Every WebTrustEngine run leaves an evidence package; the report is not a PDF page but an auditable file set. Its core: before score, after score, changed files, rollback manifest, external actions, the runtime-checks list, the out-of-scope register, the QA report, the manifest and checksums.
This structure delivers two things at once: the story for the executive (what changed, what was gained) and verifiability for the auditor (which file, which hash, which boundary). We compute checksums from the real files after packaging; the manifest lists every file's size and type. The evidence package makes 'trust us' unnecessary — the files speak.
- before/after score
- changed files
- rollback manifest
- external actions
- runtime checks
- outside automated scope
- QA report
- manifest + checksum
What the engine does: Produces an auditable file set per run.
What the output is: A 10-part evidence set (score→checksums).
For decision-makers: Auditability equals credibility.
For technical teams: Hash/manifest discipline locks delivery quality.

File dictionary
The files you will meet in the delivery ZIP, each with its one-line duty
- RUN_SUMMARY.json — The run's summary record: input, mode, page count, before/after score.
- SKOR_RAPORU_*.md — The 10-domain table + fix types + external-work list.
- FIX_MANIFEST.json — Type-and-count breakdown of applied changes.
- ROLLBACK_MANIFEST.json — the backup folder path + changed and created file lists.
- DEGISEN_DOSYALAR_*.txt — The human-readable changed-file list.
- EXTERNAL_ACTION_RECIPES.md — Panel/DNS/account recipes under 24 headings.
- RUNTIME_BRIDGE_KONTROLLERI.md — The tool/metric/how map of the 53 live checks.
- OUT_OF_SCOPE_REGISTER.md — Signals the engine cannot measure automatically, with rationale.
- GODADDY_YUKLEME_TALIMATI.md — Upload + cache + verification steps.
- MANIFEST_*.csv — The file/size/type inventory of the package.
- CHECKSUMS_*.sha256 — Integrity digest of every file; produced after packaging.
- QA/PATCH/COUNT reports — The release's quality, change and count evidence.

GUIDE OUTPUTS
Which files does the usability guide become in the package?
The usability and accessibility reference guide enters the engine as a versioned catalogue; on the delivery side it becomes three files. Which of them appear in your package depends on the profile that was run. These three files are profile-dependent additions on top of the fixed core cast.
USABILITY_ACCESSIBILITY_GUIDE.json— we write it to the root of every run; it carries the versioned catalogue, the status of the rules, the scenario plans and the evidence relations.RUN_SUMMARY.jsonrecords this file and its summary.USABILITY_SITE_MEASUREMENTS.json— runs bounded structural checks, each with its limit written down, over the captured HTML: table header declarations, cell-to-header references,scopevalues, native form field name sources, button names, image alternatives,role=imgnames,aria-sort, ARIA state values and ARIA target references. Page and target counts, content summaries and a limited set of error samples are kept.USABILITY_ACCESSIBILITY_ASSESSMENT.json— combines the static results, the available browser measurements and the bounded engine-contract checks; it records each rule's bound sub-checks and each scenario's runnability status together with its missing preconditions.
We produce the last two files only on the full-passive profile. The core profile does not request this measurement stage; the step stays recorded as not requested in EXECUTION_LEDGER.json and the two files are absent from the package. Full-passive is a check profile; it is not a complete site scan. The measurement stage preserves the main scan's full coverage.
We write the module's own resource limits and any coverage gaps into the file explicitly.
Source bindings and verification in the report
The guide summary is bound to the report through source record UG01, and the automated accessibility source, where present, through UG02; the full-passive assessment is source UG03, the static measurements UG04, and the bound runtime measurements UG05. The input manifest is verified against the existing I01 record. Guide figures are recomputed inside NUMBER_PROVENANCE.json and METRIC_LINEAGE.json. The read-only integrity verification audits source digests and sizes, regenerates the guide summary and compares it with the figures in the report; a change in the guide's content or summary is not accepted silently.
What these files do not prove
- We show sub-check results and the outcomes of the broad guide rules separately in the report. A pass from a bounded automatic check does not satisfy all acceptance criteria of the broad rule.
- Reference items are not counted as executed automatic checks;
EXECUTION_LEDGER.jsonshows this step with the real check counts. - The scenarios are defined synthetic tasks. When business data, a role or account, a task goal, an expected outcome or a before/after version is not bound, the result is delivered as "not run", together with its missing preconditions.
- The human and hybrid method labels are preserved; an unmeasurable result stays unknown. Absence of evidence is not converted into success.
- Adding the guide does not show WCAG conformance, task success, site approval or risk acceptance. Representative user research is not derived from an automated result.
How to read the report
Score table
10 rows, internal readiness out of 100. Reading order: the three lowest domains → their entries in the findings list → which class (file/live/external/manual).
Findings list
Domain · severity · file · class columns. 'High severity + ENTEGRE (integrated)' rows are first SafeFix candidates; 'UZMAN (expert)' rows go to the approval queue.
Rollback manifest
Verify the backup folder path and the two lists (changed/created); archive it. A reversal drill is five minutes of cheap insurance.
Deploy-Verify diff report
Compare expected ↔ live columns; an 'expected present, live missing' row is a cache or server-processing issue — check purge first.
HOW DO I VERIFY?
SHA-256 verification on three platforms
Proving a delivered file is untouched takes a minute. On macOS or Linux: shasum -a 256 file.pdf or sha256sum file.pdf. On Windows PowerShell: Get-FileHash file.pdf -Algorithm SHA256. Compare the 64-character result with the matching row in the CHECKSUMS file of your delivery package. A single differing character means corruption or alteration; a match means the file in your hands is exactly the sealed file.
This small ritual is the whole site's claim in miniature: not a promise, but evidence you can reproduce.
LARGE RUNS
File budgets and verified continuation on large runs
When we examine a wide site, the evidence files grow with it. So the budgets are finite, and we read all of them from a single central limit definition. The caps by role are:
- Local WTE run evidence — 256 MiB
- Report context and numeric source trace — 256 MiB per file
- Metric lineage — 512 MiB
- General delivery file — 512 MiB
- Verified report package — 2 GiB
The general JSON budget stays at 64 MiB. We select the larger budgets only from verified manifest roles. We keep the 16 MiB limit for external scan authorisation and result import, and we reject files that exceed these budgets.
We write report JSON files atomically, with their content complete and their formatting plain. The producer audits against the same role budget as the verifier before writing; an overflow neither replaces the previous file nor publishes a partial one.
The quality gate reads a number together with its label
We also verify integer claims in the document against the Turkish thousands separator, where a dot groups digits in threes: the same integer written with those dots and without them is read as one value. The mapping accepts only valid three-digit dot groups. A value must sit next to its own label, and every representation carrying that label must agree. A number that is grouped incorrectly, differs, or appears next to another measurement does not pass the quality gate. The regression check also covers the real Word and PDF conversion.
Live collection budget and verified continuation
In the operator-triggered, authorised read-only URL mode, we set the live collection budget separately and explicitly: at most 7,200 seconds of duration, between 1 MiB and 1 GiB of total data, and between 1 and 100,000 requests. Values left unspecified keep the crawler's current defaults. The real budget and the share consumed stay in the snapshot manifest.
You can continue an incomplete run without downloading its collected snapshot again; the verified continuation option re-runs every analysis from the start. The target, the profile, the page cap and the configuration must be identical. The raw capture, the normalised analysis copy, the manifest links and the file inventory are verified by size and SHA-256; a modified source, or one containing a symbolic link, is rejected.
The previous input manifest is preserved under the package's recovery folder; SCAN_RECOVERY.json records the time of the continuation and its source links. Completed and published runs cannot be altered this way, and a process lock prevents concurrent writes to the same run. Crawler measurements and analyses run again, while the earlier collection time and any collection limits are preserved. This option requires a verifiable snapshot and its input manifest.
SIX FILES
The six files of an evidence package, one by one
Every engagement produces a package with a fixed cast. Changed files — the flat list of every touched path. FIX_MANIFEST.json — per-file before/after hashes; the spine of accountability. ROLLBACK_MANIFEST.json — the single-step way back. diff report — each change in context, reviewable line by line. score pair — before and after on the same ten-domain ruler. run log — when, on what, with which engine seal. Six files, one property: any third party can re-derive the story without asking anyone.
The Sample output section at the top of this page comes from a real run over this site's own package: it shows the format, the language and the evidence discipline.
How to read a score pair
Three sample rows are enough to read a before/after pair; the three pairs below are a representative reading example. Technical SEO 62→81: the jump is large and comes from the meta layer that SafeFix covers directly — expected behaviour. Security Headers 40→40: unchanged, because headers are processed at the server, not in files; we deliver the recipe, and the rise appears only in the post-deploy live pull.
Accessibility 71→74: a small gain, because few items are automatically fixable; the remaining distance sits in the outside-automated-scope class. The shared lesson of the three rows: the score is not a grade but a map of which work waits at which layer. Two traps to keep in mind when interpreting a pair: domain weights are not equal, so the discussion is about domain rows, not totals; and a change in the file set between two runs makes scores incomparable — which is exactly why we attach the run log next to the pair.
The score lives only in the package we deliver to the client. The only thing made public is the method: how the ruler is built, how the pair is read, and what the log carries — not the number itself. A number without context is the raw material of misunderstanding.
Why is the run log part of the package?
The run log is the time dimension of the evidence: it records on which date, over which file set, and under which engine seal the work ran. If two runs disagree, this is the first place to look — did the file set change, or the engine version? Without the log a score pair floats in the air; with it, every number becomes the output of a reproducible experiment.
The log format is plain: plain text, a timestamp, a file count, a seal digest. We chose this plainness over fancy dashboards: evidence that still opens ten years from now is worth more than looking pretty today.
Quick answers
What is delivered?
Engine + fixed site + rollback + score + recipes + report.
Format?
ZIP + MD/DOCX/PDF + CSV.