Inspect the input
Read the page’s declared scripts, styles, images and links. Review the candidates and the generated retrieval plan.
ProofShotby The Proof FoundryCapture & evidence workbench
Keep the context. Build the evidence.
A local workbench for capturing page resources, organizing a case and exporting a bundle you can verify later.
Made for the way you work
From page context to a portable record.
This engine captures page structure and resources. It does not take pixel screenshots.
Organize the case
Keep a matter together in a named local folder, with its items and timestamps.
Export and check
Create a bundle with SHA-256 manifests, a Proof Passport and an offline verifier.
Inside the workbench
Follow the work.
Keep the context.
A guided look at the engine screens — these preview captures predate the rebrand; the released v2.0.0 interface ships ProofShot branding.
Earlier screenshots of the workbench, export and records steps have been retired.
Inside the workbench
The record travels with the work.
Keep the files and the checks together. Re-verify an export from disk, or use its included HTML verifier in a browser. Hashes detect changes; they do not establish legal certification.
● TAMPER-EVIDENT, NOT COURT-CERTIFIED
Earlier screenshots of this step have been retired.
Public release
Download ProofShot v2.0.0.
ProofShot v2.0.0 is the first public release under the ProofShot name — the hardened rebrand of the qualified HyperSnatch engine, published 17 September 2026. The installer is unsigned: Windows SmartScreen will prompt on first launch, so verify the SHA-256 below before running.
fa20dc7e44440f0ed96fa08db67a77339d595f8eb27090e24120104ea6744701
Windows verification: Get-FileHash ".\ProofShot-Setup-2.0.0.exe" -Algorithm SHA256
Unsigned build — not Microsoft publisher signed. Verify the checksum, then choose More info → Run anyway. Artifact identity is covered by SHA-256 checksums plus a release manifest that names Proof Foundry's internal Reality Gate receipts (the receipts are not published), not Authenticode.
Open finding: licensing authority
After the v2.0.0 release, a licensing-authority finding was recorded and is still open. Its scope and impact have not been published yet. Until they are, read the 60/60 tamper, authority and migration result as release-time testing only; it does not show that this finding is resolved.
Deeper recordProof & technical recordIdentity & migration, privacy & data flow, release evidence, limitations, receipts.
Release & migration truth
The ProofShot rebrand, stated plainly.
ProofShot v2.0.0 is the completed rebrand of the qualified HyperSnatch engine — new identity, hardened runtime, and a non-destructive migration of existing HyperSnatch profiles.
The production brand pack and the shipped v2.0.0 application now carry the ProofShot name end to end — installer, shell, and UI. One deliberate exception remains inside exported proof bundles: the offline verifier file keeps the VERIFY-HYPERSNATCH.html name so bundles exported by the legacy engine and by ProofShot verify identically.
- Public name
- ProofShot — the active product identity used by this page and the brand pack.
- Current codebase
- ProofShot 2.0.0 — the qualified engine, rebranded and hardened.
- Rebrand status
- Complete — v2.0.0 ships ProofShot identity and migrates HyperSnatch profiles on first launch.
- Parent
- The Proof Foundry — the studio that produces ProofShot.
For a closer lookRelease evidence & technical details
This section documents the ProofShot v2.0.0 public release and the qualification evidence behind it.
Status Public release
Version v2.0.0
Platform Windows
Tests 262/262 unit · 45/45 packaged E2E · 60/60 tamper+authority+migration
Proof Licensing finding open · unsigned
Release report 2026-09-17
Open finding: licensing authority
After the v2.0.0 release, a licensing-authority finding was recorded and is still open. Its scope and impact have not been published yet. Until they are, read the 60/60 tamper, authority and migration result as release-time testing only; it does not show that this finding is resolved.
SmartDecode capture & candidate rankingstructural intake, never autonomous
One workbench takes it in. Nothing runs by itself.
SmartDecode parses page structure from supplied HTML locally. Entering a URL generates a retrieval plan for operator review. When the operator runs the capture stage, ProofShot fetches page resources over HTTPS. Exported proof bundles reside on local disk and can be verified 100% offline.
SmartDecode (v2.5.0, built into this engine) works on the page's own text. It reads the structure the page declares for itself — scripts, stylesheets, images, links, embedded declarations — and separates what is real from what is not.
- Everything is resolved locally during analysis: no account, no upload, no cloud hop.
- Refusals are kept apart from candidates, so the operator sees what was dismissed and why.
- A full capture keeps the page's own artifacts and structure, not just a summary.
Capture is structural, not photographic. This build reads and records the page's own resources and receipts; there is no pixel-screenshot engine in it. Below, the engine's status bar reports a SmartDecode run: two candidates identified, best target selected. Its welcome panel still covers the workspace.
What it reads
Scripts, stylesheets, images, links, and encoded declarations — the page's own references.
Refusals separated
Incomplete or non-extractable references are refused, listed separately, never mixed into results.
Local analysis & offline verification
SmartDecode parses HTML locally. Target URL retrieval runs over HTTPS when initiated by the operator. Exported proof bundles verify 100% offline in any browser.
A plan you can read — and run yourself.
Decode produces candidates, ranks them, and says which one is the best target and why. Then it hands you a plan — it never acts on your behalf.
Every candidate gets a confidence score and a place in a deterministic ranking. The best target is selected the same way every time, and the extraction table shows the source and the score. A retrieval plan is generated from the result — a command the operator can run, change, or ignore.
- Candidate rows show what was found, where it came from, and how confident the engine is.
- The plan is output, not action. Nothing is fetched, downloaded, or executed automatically.
- Results are deterministic: the same input produces the same ranking on every run.
Confidence, with reasons
Scores come from the extraction pipeline itself and sort deterministically.
Best target selected
One candidate is chosen as the best — the one the plan is built around.
Operator runs the plan
The generated plan is a starting point for the operator, never an autonomous action.
Cases & local organizationone folder per engagement
One folder per engagement.
Everything captured for one matter stays together, locally, in a simple project container.
A case is a workspace folder with a name and an ID — created in one click from the Cases panel. Items added to it keep their timestamps, and the case list shows the count at a glance. It is deliberately simple: a container for evidence and its receipts, not a team collaboration system.
- Create a case, name it, and it appears with its own ID and creation time.
- Items hold their own hashes and receipts inside the case folder.
- The whole workspace lives on the machine — no cloud project, no shared account.
Earlier screenshots of this step have been retired.
One-click case
Create a named case from the Cases panel; it appears with its own ID.
Local timestamps
Every item and case carries the machine's own time when it was recorded.
Simple by design
No team workspaces, no shared projects — a container, on purpose, per the product freeze.
Proof bundles & export anatomypassport, manifests, fixed layout
Export a bundle you can hand over.
One export writes the whole matter to a folder you choose: the captured page, its artifacts, and the proof files that let anyone check it later.
The proof bundle is the product. Its layout is fixed and documented, and every file in it is covered by a SHA-256 manifest. A Proof Passport states what the bundle is, when it was exported, and why — and the bundle carries its own offline verifier so someone with zero software can check it.
- One export writes the full bundle: artifacts, captured page, receipts, manifests, and the verifier.
- Proof Passport summarises the matter; SHA256SUMS.txt covers every file.
- The proof-card stack (passport, tamper trial, diff, nutrition) shows everything that can be proven about the workspace at a glance.
Earlier screenshots of this step have been retired.
HyperSnatch-Proof-Bundle-<timestamp>/
├─ PROOF-PASSPORT.json # what this bundle is, when, and why
├─ SHA256SUMS.txt # every file, one hash each
├─ README.txt # how to verify, in plain text
├─ VERIFY-HYPERSNATCH.html # offline verifier (carrying legacy engine filename)
├─ artifacts/ # the captured resources
├─ captured-page/ # what the page actually was
└─ proof/ # receipts + machine-readable manifest
Offline verification & tamper trialverify it later offline, with the verifier included in the proof bundle (ProofShot's own code)
Verify it later offline, with the verifier included in the proof bundle (ProofShot's own code).
The whole point of the bundle is that it outlives the tool that made it.
Proof is checked against the files, not against this product. Prove It Again re-verifies an exported bundle directly from disk, and the offline verifier shipped inside the bundle does the same job on any machine with a browser. The Tamper Trial proves the system sees changes: it runs four temp copies of the bundle — a modified artifact, a missing hashed file, an altered passport, and a deleted verifier — and each tamper is caught.
- Prove It Again recomputes and compares hashes against the bundle's own manifests.
- The verifier HTML ships inside every bundle — verification needs no software install.
- The Tamper Trial is a real self-test: four tampered copies, all detected.
Earlier screenshots of this step have been retired.
What this product is not
Words matter, and the cheapest way to trust a proof tool is to be exact about its limits:
- Not court-certified — nothing here certifies anything for court.
- Not a legal chain-of-custody — we record hashes and receipts, not custody.
- Tamper-evident, not tamper-proof — changes are detected and reported by SHA-256 hash comparison; nothing is unhackable.
- Not a legal evidence platform — verification is the operator's to interpret.
- Not a media ripping utility — capture is one input type into a proof bundle, not the product's purpose.
- Not ProofForge — that is a separate project; the names are not interchangeable.
Release status & engine evidencequalification record, rebrand state
Release status & evidence
Current state of the released codebase.
- Public status
- PUBLIC RELEASE — v2.0.0, published 17 September 2026
- Historical release qualification
- 262/262 unit · 45/45 packaged E2E · 60/60 tamper+authority+migration
- Codebase
- ProofShot 2.0.0 (Electron + SmartDecode v2.5.0) — the hardened HyperSnatch rebrand
- Public installer
- RELEASED — ProofShot-Setup-2.0.0.exe via Proof Foundry downloads
- Signing model
- UNSIGNED (no Authenticode) — SHA-256 checksums plus a release manifest that names Proof Foundry's internal Reality Gate receipts (the receipts are not published) carry identity
- ProofStrip status
- Licensing finding open · unsigned
Public release v2.0.0 (Windows). Unsigned installer — Windows SmartScreen will prompt; verify the SHA-256 first (More info → Run anyway). Custody: source 6e7fc6bf, deterministic asar, fuses enforced; a release-time adversarial gate (operator not published) reported green. Migrates existing HyperSnatch profiles non-destructively on first launch.
v2.0.0 is the first public ProofShot release. It migrates existing HyperSnatch profiles non-destructively (copy, not move) on first launch.
Known limitationswhat is true right now
Known limitations
Honest about what is not ready.
Licensing authority review
The 60/60 tamper, authority and migration result documents release-time qualification. A later licensing-authority finding remains unresolved; that historical result does not establish remediation of the later finding.
Unsigned Windows installer
ProofShot-Setup-2.0.0.exe is not Authenticode-signed, so Windows SmartScreen will warn on first launch. Verify the published SHA-256, then choose More info → Run anyway. Artifact identity is backed by SHA-256 checksums plus a release manifest that names Proof Foundry's internal Reality Gate receipts (the receipts are not published).
Screenshots predate the rebrand
The preview captures on this page show the v1.6.18 engine under the HyperSnatch name. The released v2.0.0 interface ships ProofShot branding; refreshed captures are pending.
Capture is structural, not photographic
SmartDecode reads and records the page's own resources and structure. There is no pixel-screenshot capture engine in this build.
Scoped by the product freeze
No new extraction engines or automation lanes while the freeze stands. Cases stay simple project containers, and proof means SHA-256 manifests and receipts.
Privacy & Data Flow
Local analysis. HTTPS intake. Offline verification.
Evidence-backed behavior for ProofShot v2.0.0.
Local SmartDecode analysis
SmartDecode parses page structure from supplied HTML text locally (LOCAL_PROCESS_ONLY). Pasting a URL generates a retrieval plan for operator review without auto-fetching.
HTTPS URL resource intake
When the operator explicitly runs the retrieval stage, ProofShot fetches page structure, stylesheets, scripts, and images over HTTPS from the target URL.
Offline verification & storage
Captured evidence bundles, Proof Passports, and SHA-256 manifests reside in local Case folders on disk and can be verified 100% offline in any browser.
Capture & evidence workbench · v2.0.0
Keep the context.
Build the evidence.
ProofShot v2.0.0 is out. Verify the checksum, install, and keep your proof local.