Struct BackendReport 

pub struct BackendReport {
    pub active: Backend,
    pub candidate: Backend,
    pub candidate_detection_mode: CandidateDetectionMode,
    pub simd_feature_enabled: bool,
    pub accelerated_backend_active: bool,
    pub unsafe_boundary_enforced: bool,
    pub security_posture: SecurityPosture,
    pub wipe_posture: WipePosture,
    pub ct_gate_posture: CtGatePosture,
}

Backend report for the current build and target.

Fields

active: Backend

Backend currently used for admitted runtime dispatch.

This field reports the primary active backend used by the established encode dispatch boundary. Decode has its own narrower admission path; use Self::active_decode_backend to inspect decode dispatch.

candidate: Backend

Strongest backend candidate visible to the current build.

candidate_detection_mode: CandidateDetectionMode

Whether candidate visibility came from runtime CPU probing, compile-time target features, or a disabled SIMD feature.

simd_feature_enabled: bool

Whether the simd feature is enabled in this build.

accelerated_backend_active: bool

Whether an accelerated SIMD backend is active.

unsafe_boundary_enforced: bool

Whether this build keeps the high-assurance scalar unsafe boundary.

This is a conservative compile-time posture signal. It is true only when the reserved simd feature is disabled; simd builds expose additional private prototype boundaries and must use the release evidence scripts for boundary validation.

security_posture: SecurityPosture

Current security posture.

wipe_posture: WipePosture

Current wipe-barrier posture.

ct_gate_posture: CtGatePosture

Current constant-time result-gate barrier posture.

Implementations

impl BackendReport

pub const fn satisfies(self, policy: BackendPolicy) -> bool

Returns whether this report satisfies policy.

let report = base64_ng::runtime::backend_report();

let scalar_only =
    report.satisfies(base64_ng::runtime::BackendPolicy::ScalarExecutionOnly);
assert_eq!(scalar_only, !report.accelerated_backend_active);

pub const fn candidate_required_cpu_features(self) -> &'static [&'static str]

Returns the CPU features required by the detected candidate.

let report = base64_ng::runtime::backend_report();

assert_eq!(
    report.candidate_required_cpu_features(),
    report.candidate.required_cpu_features(),
);

pub fn active_decode_backend(self) -> Backend

Returns the active backend for the normal strict decode boundary.

This is intentionally separate from Self::active. In the 1.3.0 decode line, strict decode may admit a narrower backend than encode; unsupported decode surfaces still return scalar here through the public API fallback rules.

pub const fn memory_lock_posture(self) -> MemoryLockPosture

Returns whether base64-ng itself locks secret buffers into physical memory.

This crate intentionally has no OS-specific mlock/VirtualLock integration. High-assurance deployments should pair secret buffers with their own platform-approved memory-locking, swap, hibernation, and crash-dump controls.

pub const fn snapshot(self) -> BackendSnapshot

Returns a compact structured snapshot with stable string values.

let snapshot = base64_ng::runtime::backend_report().snapshot();

assert_eq!(
    snapshot.accelerated_backend_active,
    snapshot.active != "scalar",
);

Trait Implementations

impl Clone for BackendReport

fn clone(&self) -> BackendReport

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BackendReport

impl Debug for BackendReport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for BackendReport

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for BackendReport

impl PartialEq for BackendReport

fn eq(&self, other: &BackendReport) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for BackendReport