Signed by an ed25519 key.
Anyone with the public key can verify it.

Option A — Run the bundled verifier

The qev-platform repo ships a standalone verifier that does both checks using only the Python cryptography library.

git clone https://github.com/TheArtOfSound/qev-platform
cd qev-platform
uv run python scripts/verify_site_integrity.py --url https://secure.imagineqira.com

Illustrative output on success. The file count is whatever the manifest lists when you run it, so do not treat the number below as a fixed expectation — read it from the record above:

Step 1: ed25519 signature...
  OK
Step 2: SHA-256 file hashes...
  OK (<N> files, matching file_count in the manifest)

VERIFIED. The manifest is signed by the holder of the ed25519 private
key corresponding to the published public key, and every file's SHA-256
matches.

Option B — Verify the signature manually

Fetch the public key and the manifest, then verify the ed25519 signature with any standard library. Python example:

import hashlib, json, urllib.request
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

BASE = "https://secure.imagineqira.com"
DOMAIN = b"BRY-NFET-SX|SITE-INTEGRITY|V2"

# 1. Fetch the public key and the signed manifest.
pub_hex = urllib.request.urlopen(BASE + "/site-signer.ed25519.pub").read().strip().decode()
pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(pub_hex))
record = json.loads(urllib.request.urlopen(BASE + "/site-integrity.json").read())

# 2. Strip the signature block and reconstruct the signed bytes exactly
#    as the signer did: the domain separator bytes above, with nothing
#    appended to them, immediately followed by COMPACT canonical JSON --
#    sorted keys, separators (',', ':') so there is no whitespace, and
#    ensure_ascii=False. Any other formatting (indent=2, default
#    separators, an extra delimiter after the domain) yields different
#    bytes and pub.verify() below will raise InvalidSignature.
manifest = {k: v for k, v in record.items() if k != "signature"}
canonical = json.dumps(
    manifest, sort_keys=True, separators=(",", ":"), ensure_ascii=False
).encode("utf-8")
signed_bytes = DOMAIN + canonical

# 3. Verify. Raises InvalidSignature on mismatch.
pub.verify(bytes.fromhex(record["signature"]["signature_hex"]), signed_bytes)
print("signature OK")

# 4. Hash every file and compare.
for name, expected in record["files"].items():
    body = urllib.request.urlopen(f"{BASE}/{name}").read()
    actual = hashlib.sha256(body).hexdigest()
    assert actual == expected, f"{name}: {actual} != {expected}"
    print(f"  {name}: OK")

Known discrepancy — trust the construction above, not the prose in the record: the record's signature.canonical_json_note field writes the domain separator with a trailing ||. That is wrong: the signature verifies over the separator with nothing appended to it. That note lives inside the signature block, which is stripped out before signing, so it is not covered by the signature and carries no cryptographic weight either way.

Option C — Just check a single file's hash

If you trust the signed manifest itself (because you already checked the ed25519 signature, or because you're only worried about over-the-wire tampering with a single file), you can just compare a SHA-256 digest with shasum:

curl -s https://secure.imagineqira.com/ | shasum -a 256
# compare against files["index.html"] in the integrity record above