crtx 0.1.0

//! `cortex release` — release authority preflight gates.

use std::fs;
use std::path::PathBuf;

use chrono::{Duration, Utc};
use clap::{Args, Subcommand};
use cortex_core::{
    compose_policy_outcomes, AuthorityClass, ClaimCeiling, ClaimProofState, PolicyContribution,
    PolicyOutcome, RuntimeMode,
};
use cortex_runtime::{runtime_claim_preflight_with_policy, RuntimeClaimKind};
use cortex_verifier::{
    ceiling_from_state, verify_with_policy, EvidenceInput as VerifierEvidenceInput,
    EvidenceKind as VerifierEvidenceKind, IndependentWitness, VerifiedTrustState,
};
use serde::Deserialize;
use serde_json::json;

use crate::cmd::from_store::{self, FromStoreArgs, Surface};
use crate::exit::Exit;
use crate::output::{self, Envelope};

const RELEASE_FORBIDDEN_USES: &[&str] = &[
    "release_readiness_artifact",
    "trusted_stdout_artifact",
    "trusted_artifact_emission",
    "compliance_evidence",
    "cross_system_trust_decision",
    "external_reporting",
];

/// Default freshness window for independent witnesses. Mirrors the value in
/// the ADR 0041 design doc §8 (24 hours).
const DEFAULT_MAX_WITNESS_AGE_SECONDS: u64 = 86_400;

/// Release subcommands.
#[derive(Debug, Subcommand)]
pub enum ReleaseSub {
    /// Check whether this checkout may emit a release-readiness artifact.
    Readiness(ReleaseEvidenceArgs),
}

/// Release evidence input arguments.
#[derive(Debug, Args)]
pub struct ReleaseEvidenceArgs {
    /// Path to a release evidence preflight JSON file.
    #[arg(long, value_name = "PATH", conflicts_with = "evidence_json")]
    pub evidence_file: Option<PathBuf>,

    /// Inline release evidence preflight JSON.
    #[arg(long, value_name = "JSON", conflicts_with = "evidence_file")]
    pub evidence_json: Option<String>,

    /// Lowercase BLAKE3 digest of the exact release evidence input bytes.
    #[arg(long, value_name = "HEX")]
    pub evidence_blake3: Option<String>,

    /// Path to an `IndependentWitness` JSON document. Repeatable.
    #[arg(long = "witness-file", value_name = "PATH", action = clap::ArgAction::Append)]
    pub witness_file: Vec<PathBuf>,

    /// Inline `IndependentWitness` JSON. Repeatable.
    #[arg(long = "witness-json", value_name = "JSON", action = clap::ArgAction::Append)]
    pub witness_json: Vec<String>,

    /// Maximum witness age in seconds before the witness is considered stale.
    #[arg(long = "max-witness-age-seconds", value_name = "N", default_value_t = DEFAULT_MAX_WITNESS_AGE_SECONDS)]
    pub max_witness_age_seconds: u64,

    /// Witness-assembly flags. When `--from-store` is set, the command opens
    /// the local Cortex store and reports which of the four ADR 0041 witness
    /// axes are present locally. See `from_store` module for the stable
    /// invariant strings emitted for each missing axis.
    #[command(flatten)]
    pub from_store: FromStoreArgs,
}

/// Run a release authority command.
pub fn run(sub: ReleaseSub) -> Exit {
    match sub {
        ReleaseSub::Readiness(args) => run_readiness(args),
    }
}

#[derive(Debug, Deserialize)]
struct ReleaseEvidenceInput {
    evidence_kind: String,
    runtime_mode: RuntimeMode,
    authority_class: AuthorityClass,
    proof_state: ClaimProofState,
    claim_ceiling: ClaimCeiling,
    policy_outcome: PolicyOutcome,
    source_refs: Vec<String>,
}

struct ReleaseEvidenceEvaluation {
    contributions: Vec<PolicyContribution>,
    evidence_report: serde_json::Value,
    runtime_mode: RuntimeMode,
    authority_class: AuthorityClass,
    proof_state: ClaimProofState,
    requested_ceiling: ClaimCeiling,
    /// Verifier output, if the producer-supplied evidence reached the
    /// verifier-call slot. `None` for every short-circuit path (missing
    /// input, read failure, advisory-only, malformed source refs, etc.).
    verifier_state: Option<VerifiedTrustState>,
}

fn run_readiness(args: ReleaseEvidenceArgs) -> Exit {
    // `--from-store` short-circuits to local witness-axis assembly.
    if args.from_store.from_store {
        return run_readiness_from_store(args);
    }
    let evaluation = match evaluate_release_evidence(args) {
        Ok(evaluation) => evaluation,
        Err(err) => {
            eprintln!("cortex release readiness: failed to build policy contribution: {err:?}");
            return Exit::Internal;
        }
    };
    let policy = compose_policy_outcomes(evaluation.contributions, None);
    let preflight = runtime_claim_preflight_with_policy(
        "release readiness artifact",
        RuntimeClaimKind::ReleaseReadiness,
        evaluation.runtime_mode,
        evaluation.authority_class,
        evaluation.proof_state,
        evaluation.requested_ceiling,
        &policy,
    );

    let trusted_artifact_emitted = evaluation
        .verifier_state
        .as_ref()
        .is_some_and(VerifiedTrustState::is_full_chain_verified)
        && preflight.allowed;
    let independent_verification = trusted_artifact_emitted;

    let verifier_report = verifier_report_value(&evaluation.verifier_state);

    let report = json!({
        "command": "release.readiness",
        "artifact_emitted": trusted_artifact_emitted,
        "trusted_artifact_emitted": trusted_artifact_emitted,
        "trusted_stdout_artifact": trusted_artifact_emitted,
        "independent_verification": independent_verification,
        "forbidden_uses": RELEASE_FORBIDDEN_USES,
        "runtime_mode": preflight.claim.runtime_mode,
        "proof_state": preflight.claim.proof_state,
        "claim_ceiling": preflight.claim.effective_ceiling,
        "required_ceiling": preflight.claim.required_ceiling,
        "claim_allowed": preflight.allowed,
        "preflight_reason": preflight.reason,
        "downgrade_reasons": preflight.claim.reasons,
        "policy_outcome": policy.final_outcome,
        "policy_contributing": policy.contributing,
        "policy_discarded": policy.discarded,
        "evidence_input": evaluation.evidence_report,
        "verifier": verifier_report,
    });

    let exit = Exit::PreconditionUnmet;
    if output::json_enabled() {
        let policy_summary = serde_json::json!({
            "final_outcome": policy.final_outcome,
            "contributing": policy.contributing,
            "discarded": policy.discarded,
        });
        let envelope = Envelope::new("cortex.release.readiness", exit, report)
            .with_policy_outcome(policy_summary);
        return output::emit(&envelope, exit);
    }
    match serde_json::to_string_pretty(&report) {
        Ok(serialized) => eprintln!("{serialized}"),
        Err(err) => {
            eprintln!("cortex release readiness: failed to serialize preflight report: {err}");
            return Exit::Internal;
        }
    }

    if trusted_artifact_emitted {
        Exit::Ok
    } else {
        Exit::PreconditionUnmet
    }
}

/// `--from-store` branch of `cortex release readiness`. Opens the local
/// Cortex store, attempts to assemble each of the four ADR 0041 witness
/// axes, and emits a fail-closed advisory naming every missing axis with
/// a stable invariant string. Until the four-witness composition can be
/// satisfied entirely from local state (which today requires ADO build
/// evidence + Rekor + OTS receipt lookup wiring that does not exist), the
/// command always emits `trusted_artifact_emitted: false`.
fn run_readiness_from_store(args: ReleaseEvidenceArgs) -> Exit {
    let assembly = match from_store::assemble(&args.from_store, Surface::Release) {
        Ok(a) => a,
        Err(exit) => return exit,
    };
    from_store::emit_report(
        &assembly,
        "release.readiness.from_store",
        "cortex.release.readiness",
        RELEASE_FORBIDDEN_USES,
    )
}

fn evaluate_release_evidence(
    args: ReleaseEvidenceArgs,
) -> Result<ReleaseEvidenceEvaluation, cortex_core::PolicyError> {
    let raw = match read_release_evidence_input(&args) {
        Ok(Some(raw)) => raw,
        Ok(None) => {
            return Ok(ReleaseEvidenceEvaluation {
                contributions: vec![PolicyContribution::new(
                    "release.remote_ci_evidence",
                    PolicyOutcome::Reject,
                    "remote CI evidence is unavailable; release readiness cannot be claimed",
                )?],
                evidence_report: json!({
                    "present": false,
                    "accepted": false,
                    "accepted_as": "none",
                    "trusted_evidence_input_present": false,
                    "verification_state": "missing_input",
                    "failed_rule": "release.evidence_input.missing",
                    "missing_evidence": ["release.evidence_input"],
                    "independent_verification": false,
                    "trusted_artifact_emitted": false,
                    "forbidden_uses": RELEASE_FORBIDDEN_USES,
                    "reason": "missing release evidence input",
                }),
                runtime_mode: RuntimeMode::LocalUnsigned,
                authority_class: AuthorityClass::Observed,
                proof_state: ClaimProofState::Partial,
                requested_ceiling: ClaimCeiling::AuthorityGrade,
                verifier_state: None,
            });
        }
        Err(err) => {
            return Ok(ReleaseEvidenceEvaluation {
                contributions: vec![PolicyContribution::new(
                    "release.evidence_input_read",
                    PolicyOutcome::Reject,
                    format!("release evidence input could not be read: {err}"),
                )?],
                evidence_report: json!({
                    "present": true,
                    "accepted": false,
                    "accepted_as": "none",
                    "trusted_evidence_input_present": false,
                    "verification_state": "read_failed",
                    "failed_rule": "release.evidence_input.read_failed",
                    "missing_evidence": ["release.evidence_input_readable"],
                    "independent_verification": false,
                    "trusted_artifact_emitted": false,
                    "forbidden_uses": RELEASE_FORBIDDEN_USES,
                    "reason": "release evidence input could not be read",
                }),
                runtime_mode: RuntimeMode::Unknown,
                authority_class: AuthorityClass::Untrusted,
                proof_state: ClaimProofState::Unknown,
                requested_ceiling: ClaimCeiling::AuthorityGrade,
                verifier_state: None,
            });
        }
    };

    let input_text = match std::str::from_utf8(&raw) {
        Ok(text) => text,
        Err(err) => {
            return Ok(ReleaseEvidenceEvaluation {
                contributions: vec![PolicyContribution::new(
                    "release.evidence_input_parse",
                    PolicyOutcome::Reject,
                    format!("release evidence input is not UTF-8 JSON: {err}"),
                )?],
                evidence_report: json!({
                    "present": true,
                    "accepted": false,
                    "accepted_as": "none",
                    "trusted_evidence_input_present": false,
                    "verification_state": "parse_failed",
                    "failed_rule": "release.evidence_input.invalid_json",
                    "missing_evidence": ["release.evidence_input_valid_authority_json"],
                    "independent_verification": false,
                    "trusted_artifact_emitted": false,
                    "forbidden_uses": RELEASE_FORBIDDEN_USES,
                    "reason": "invalid release evidence JSON",
                }),
                runtime_mode: RuntimeMode::Unknown,
                authority_class: AuthorityClass::Untrusted,
                proof_state: ClaimProofState::Unknown,
                requested_ceiling: ClaimCeiling::AuthorityGrade,
                verifier_state: None,
            });
        }
    };

    let input = match serde_json::from_str::<ReleaseEvidenceInput>(input_text) {
        Ok(input) => input,
        Err(err) => {
            return Ok(ReleaseEvidenceEvaluation {
                contributions: vec![PolicyContribution::new(
                    "release.evidence_input_parse",
                    PolicyOutcome::Reject,
                    format!("release evidence input is not valid authority JSON: {err}"),
                )?],
                evidence_report: json!({
                    "present": true,
                    "accepted": false,
                    "accepted_as": "none",
                    "trusted_evidence_input_present": false,
                    "verification_state": "parse_failed",
                    "failed_rule": "release.evidence_input.invalid_json",
                    "missing_evidence": ["release.evidence_input_valid_authority_json"],
                    "independent_verification": false,
                    "trusted_artifact_emitted": false,
                    "forbidden_uses": RELEASE_FORBIDDEN_USES,
                    "reason": "invalid release evidence JSON",
                }),
                runtime_mode: RuntimeMode::Unknown,
                authority_class: AuthorityClass::Untrusted,
                proof_state: ClaimProofState::Unknown,
                requested_ceiling: ClaimCeiling::AuthorityGrade,
                verifier_state: None,
            });
        }
    };

    if release_evidence_is_advisory_only(&input) {
        return Ok(ReleaseEvidenceEvaluation {
            contributions: vec![PolicyContribution::new(
                "release.remote_ci_evidence",
                PolicyOutcome::Reject,
                "release evidence input is advisory-only and cannot support release readiness",
            )?],
            evidence_report: json!({
                "present": true,
                "accepted": false,
                "accepted_as": "none",
                "trusted_evidence_input_present": false,
                "verification_state": "advisory_only",
                "failed_rule": "release.evidence_input.advisory_only",
                "missing_evidence": ["release.authority_grade_remote_ci_evidence"],
                "independent_verification": false,
                "trusted_artifact_emitted": false,
                "forbidden_uses": RELEASE_FORBIDDEN_USES,
                "reason": "release evidence input is advisory-only and cannot support a trusted release-readiness artifact",
                "evidence_kind": input.evidence_kind,
                "runtime_mode": input.runtime_mode,
                "authority_class": input.authority_class,
                "proof_state": input.proof_state,
                "claim_ceiling": input.claim_ceiling,
                "input_policy_outcome": input.policy_outcome,
                "source_ref_count": input.source_refs.len(),
                "advisory_only": true,
            }),
            runtime_mode: input.runtime_mode,
            authority_class: input.authority_class,
            proof_state: input.proof_state,
            requested_ceiling: input.claim_ceiling,
            verifier_state: None,
        });
    }

    let actual_blake3 = blake3_hex(&raw);
    let digest_verified = args
        .evidence_blake3
        .as_deref()
        .map(|expected| expected == actual_blake3)
        .unwrap_or(false);
    let source_refs_present = !input.source_refs.is_empty();
    let source_refs_valid = input
        .source_refs
        .iter()
        .all(|source_ref| release_source_ref_has_authority_shape(source_ref));
    let authority_grade_shape = input.evidence_kind == "remote_ci"
        && source_refs_valid
        && source_refs_present
        && digest_verified
        && input.runtime_mode == RuntimeMode::AuthorityGrade
        && input.authority_class == AuthorityClass::Operator
        && input.proof_state == ClaimProofState::FullChainVerified
        && input.claim_ceiling == ClaimCeiling::AuthorityGrade
        && input.policy_outcome == PolicyOutcome::Allow;

    if !authority_grade_shape {
        let failed_rule = release_evidence_failed_rule(
            &args,
            &input,
            digest_verified,
            source_refs_present,
            source_refs_valid,
        );
        let missing_evidence = release_missing_evidence_for_failed_rule(failed_rule);
        return Ok(ReleaseEvidenceEvaluation {
            contributions: vec![PolicyContribution::new(
                "release.remote_ci_evidence",
                PolicyOutcome::Reject,
                "release evidence input is missing authority-grade remote CI proof",
            )?],
            evidence_report: json!({
                "present": true,
                "accepted": false,
                "accepted_as": "none",
                "trusted_evidence_input_present": false,
                "verification_state": "rejected",
                "failed_rule": failed_rule,
                "missing_evidence": missing_evidence,
                "independent_verification": false,
                "trusted_artifact_emitted": false,
                "forbidden_uses": RELEASE_FORBIDDEN_USES,
                "reason": "release evidence input is not authority-grade remote CI evidence",
                "evidence_kind": input.evidence_kind,
                "input_policy_outcome": input.policy_outcome,
                "source_ref_count": input.source_refs.len(),
                "source_refs_present": source_refs_present,
                "source_refs_valid": source_refs_valid,
                "digest_verified": digest_verified,
            }),
            runtime_mode: input.runtime_mode,
            authority_class: input.authority_class,
            proof_state: input.proof_state,
            requested_ceiling: input.claim_ceiling,
            verifier_state: None,
        });
    }

    // Authority-grade shape reached. Hand off to the ADR 0041 verifier.
    let witnesses = match load_witnesses(&args) {
        Ok(witnesses) => witnesses,
        Err(detail) => {
            return Ok(ReleaseEvidenceEvaluation {
                contributions: vec![PolicyContribution::new(
                    "release.evidence_input_verification",
                    PolicyOutcome::Reject,
                    format!("witness load failed: {detail}"),
                )?],
                evidence_report: json!({
                    "present": true,
                    "accepted": false,
                    "accepted_as": "none",
                    "trusted_evidence_input_present": false,
                    "verification_state": "rejected",
                    "failed_rule": "release.evidence_input.witness_load_failed",
                    "missing_evidence": ["release.independent_witnesses"],
                    "independent_verification": false,
                    "trusted_artifact_emitted": false,
                    "forbidden_uses": RELEASE_FORBIDDEN_USES,
                    "reason": "release witness input could not be loaded",
                    "evidence_kind": input.evidence_kind,
                    "source_ref_count": input.source_refs.len(),
                    "evidence_blake3": actual_blake3,
                    "witness_load_error": detail,
                }),
                runtime_mode: input.runtime_mode,
                authority_class: input.authority_class,
                proof_state: input.proof_state,
                requested_ceiling: input.claim_ceiling,
                verifier_state: None,
            });
        }
    };

    let verifier_input = VerifierEvidenceInput {
        kind: VerifierEvidenceKind::ReleaseReadiness,
        evidence_blake3: actual_blake3.clone(),
        runtime_mode: input.runtime_mode,
        authority_class: input.authority_class,
        proof_state: input.proof_state,
        requested_ceiling: input.claim_ceiling,
        source_refs: input.source_refs.clone(),
        advisory_only: false,
    };
    let max_age = Duration::seconds(args.max_witness_age_seconds as i64);
    let verifier_state = verify_with_policy(&verifier_input, &witnesses, Utc::now(), max_age, None);

    let (verification_state, failed_rule, accepted, missing_evidence, reason): (
        &str,
        &str,
        bool,
        Vec<&str>,
        String,
    ) = match &verifier_state {
        VerifiedTrustState::FullChainVerified { .. } => (
            "full_chain_verified",
            "release.evidence_input.full_chain_verified",
            true,
            vec![],
            "release evidence input passed independent verification".into(),
        ),
        VerifiedTrustState::Partial { reasons, .. } => (
            "partial",
            "release.evidence_input.independent_verification_partial",
            false,
            vec![
                "release.remote_ci_independent_verification",
                "release.trusted_artifact_emission",
            ],
            format!(
                "release evidence input parsed, but independent verification is partial: {}",
                reasons.join("; ")
            ),
        ),
        VerifiedTrustState::Broken { edge, .. } => (
            "broken",
            "release.evidence_input.independent_verification_broken",
            false,
            vec![
                "release.remote_ci_independent_verification",
                "release.trusted_artifact_emission",
            ],
            format!(
                "release evidence input parsed, but independent verification broke at {}: {}",
                edge.invariant, edge.detail
            ),
        ),
    };
    let trusted_evidence_input_present =
        matches!(verifier_state, VerifiedTrustState::FullChainVerified { .. });
    let composer_outcome = if trusted_evidence_input_present {
        PolicyOutcome::Allow
    } else {
        PolicyOutcome::Reject
    };
    let composer_reason = if trusted_evidence_input_present {
        "release evidence input passed independent verification".to_string()
    } else {
        reason.clone()
    };

    Ok(ReleaseEvidenceEvaluation {
        contributions: vec![PolicyContribution::new(
            "release.evidence_input_verification",
            composer_outcome,
            composer_reason,
        )?],
        evidence_report: json!({
            "present": true,
            "accepted": accepted,
            "accepted_as": if accepted { "trusted_remote_ci_evidence" } else { "none" },
            "trusted_evidence_input_present": trusted_evidence_input_present,
            "verification_state": verification_state,
            "failed_rule": failed_rule,
            "missing_evidence": missing_evidence,
            "independent_verification": trusted_evidence_input_present,
            "trusted_artifact_emitted": trusted_evidence_input_present,
            "forbidden_uses": RELEASE_FORBIDDEN_USES,
            "reason": reason,
            "evidence_kind": input.evidence_kind,
            "source_ref_count": input.source_refs.len(),
            "source_refs_present": true,
            "source_refs_valid": true,
            "digest_verified": true,
            "evidence_blake3": actual_blake3,
        }),
        runtime_mode: input.runtime_mode,
        authority_class: input.authority_class,
        proof_state: input.proof_state,
        requested_ceiling: input.claim_ceiling,
        verifier_state: Some(verifier_state),
    })
}

fn verifier_report_value(state: &Option<VerifiedTrustState>) -> serde_json::Value {
    let Some(state) = state else {
        return json!({
            "invoked": false,
        });
    };
    let ceiling = ceiling_from_state(state);
    let (witnesses, reasons, edge) = match state {
        VerifiedTrustState::FullChainVerified { witnesses, .. } => {
            (witnesses.clone(), Vec::new(), None)
        }
        VerifiedTrustState::Partial { reasons, witnesses } => {
            (witnesses.clone(), reasons.clone(), None)
        }
        VerifiedTrustState::Broken { edge, witnesses } => {
            (witnesses.clone(), Vec::new(), Some(edge.clone()))
        }
    };
    json!({
        "invoked": true,
        "state": state.wire_str(),
        "ceiling": ceiling,
        "reasons": reasons,
        "broken_edge": edge,
        "witnesses": witnesses,
    })
}

fn load_witnesses(args: &ReleaseEvidenceArgs) -> Result<Vec<IndependentWitness>, String> {
    let mut witnesses: Vec<IndependentWitness> = Vec::new();
    for path in &args.witness_file {
        let bytes = fs::read(path).map_err(|err| {
            format!(
                "witness file {path} failed to read: {err}",
                path = path.display()
            )
        })?;
        let witness: IndependentWitness = serde_json::from_slice(&bytes).map_err(|err| {
            format!(
                "witness file {path} is not valid IndependentWitness JSON: {err}",
                path = path.display()
            )
        })?;
        witnesses.push(witness);
    }
    for inline in &args.witness_json {
        let witness: IndependentWitness = serde_json::from_str(inline)
            .map_err(|err| format!("--witness-json is not valid IndependentWitness JSON: {err}"))?;
        witnesses.push(witness);
    }
    Ok(witnesses)
}

fn release_missing_evidence_for_failed_rule(failed_rule: &str) -> Vec<&'static str> {
    match failed_rule {
        "release.evidence_input.missing_digest" => vec!["release.evidence_input_blake3"],
        "release.evidence_input.digest_mismatch" => vec!["release.evidence_input_matching_blake3"],
        "release.evidence_input.missing_source_refs" => vec!["release.evidence_input_source_refs"],
        "release.evidence_input.malformed_source_refs" => vec!["release.authority_source_refs"],
        "release.evidence_input.wrong_evidence_kind" => vec!["release.remote_ci_evidence_kind"],
        _ => vec!["release.authority_grade_remote_ci_evidence"],
    }
}

fn release_evidence_is_advisory_only(input: &ReleaseEvidenceInput) -> bool {
    matches!(
        input.runtime_mode,
        RuntimeMode::Dev | RuntimeMode::LocalUnsigned
    ) || matches!(
        input.evidence_kind.as_str(),
        "cortex_pre_v2_backup"
            | "pre_v2_backup"
            | "run_ledger_drill"
            | "development_ledger"
            | "local_development"
    )
}

fn release_evidence_failed_rule(
    args: &ReleaseEvidenceArgs,
    input: &ReleaseEvidenceInput,
    digest_verified: bool,
    source_refs_present: bool,
    source_refs_valid: bool,
) -> &'static str {
    if args.evidence_blake3.is_none() {
        "release.evidence_input.missing_digest"
    } else if !digest_verified {
        "release.evidence_input.digest_mismatch"
    } else if !source_refs_present {
        "release.evidence_input.missing_source_refs"
    } else if !source_refs_valid {
        "release.evidence_input.malformed_source_refs"
    } else if input.evidence_kind != "remote_ci" {
        "release.evidence_input.wrong_evidence_kind"
    } else {
        "release.evidence_input.not_authority_grade"
    }
}

fn read_release_evidence_input(
    args: &ReleaseEvidenceArgs,
) -> Result<Option<Vec<u8>>, std::io::Error> {
    match (&args.evidence_file, &args.evidence_json) {
        (Some(path), None) => fs::read(path).map(Some),
        (None, Some(json)) => Ok(Some(json.as_bytes().to_vec())),
        (None, None) => Ok(None),
        _ => unreachable!("clap prevents multiple release evidence inputs"),
    }
}

fn release_source_ref_has_authority_shape(source_ref: &str) -> bool {
    let Some((scheme, rest)) = source_ref.split_once("://") else {
        return false;
    };
    matches!(scheme, "signed" | "https")
        && !rest.trim().is_empty()
        && rest == rest.trim()
        && !rest.chars().any(char::is_whitespace)
}

fn blake3_hex(bytes: &[u8]) -> String {
    blake3::hash(bytes).to_hex().to_string()
}