Skip to main content

hns_browser_observability/
lib.rs

1//! Bounded shared status for mobile and Chromium Handshake browser products.
2//!
3//! Transport is reported independently from cryptographic evidence. Status
4//! contains no query names, URLs, certificate bytes, DNS payloads, or secrets.
5
6#![forbid(unsafe_code)]
7#![allow(
8    clippy::doc_markdown,
9    clippy::missing_errors_doc,
10    clippy::module_name_repetitions,
11    reason = "HNS, DNSSEC, TLSA, DANE, ODoH, and HNSR are protocol names"
12)]
13
14use hns_browser_runtime::{AuthorityState, RUNTIME_SCHEMA_VERSION, RuntimeSnapshot};
15pub use hns_icann_dane::IcannDnssecStatus;
16pub use hns_namespace_resolution::{Namespace, OutcomeKind, RootFailureKind, SelectionReason};
17use hns_resolution_policy::{
18    ChainAnchor, HnsrPolicy, Network, PolicySnapshot, ProviderPolicy, ResolutionTransport,
19    ValidationEvidence, WireProfile,
20};
21use thiserror::Error;
22
23/// Current shared status schema.
24pub const STATUS_SCHEMA_VERSION: u16 = 2;
25/// Maximum bytes in any reported transport identity.
26pub const MAX_IDENTITY_BYTES: usize = 256;
27/// Maximum unsupported-evidence entries in one snapshot.
28pub const MAX_UNSUPPORTED_EVIDENCE: usize = 64;
29
30/// Return the consensus name-tree commit interval for one Handshake network.
31///
32/// HSD commits accumulated name changes at the end of each interval. The
33/// resulting root first appears in the following block header, so consumers
34/// must compare authority epochs rather than requiring identical chain tips.
35#[must_use]
36pub const fn name_tree_interval(network: Network) -> u32 {
37    match network {
38        Network::Mainnet | Network::Testnet => 36,
39        Network::Regtest => 5,
40        Network::Simnet => 2,
41    }
42}
43
44/// Return the header height that introduced the name-tree root authoritative
45/// at `chain_height`.
46///
47/// Genesis has no preceding interval. For every non-genesis height, the first
48/// authority epoch begins at header 1; a commit made at interval boundary
49/// `N` first becomes visible in header `N + 1`.
50#[must_use]
51pub const fn name_tree_authority_height(network: Network, chain_height: u32) -> u32 {
52    if chain_height == 0 {
53        return 0;
54    }
55    let interval = name_tree_interval(network);
56    ((chain_height - 1) / interval) * interval + 1
57}
58
59/// Name-tree authority readiness derived from validated local and
60/// independently corroborated target header heights.
61///
62/// This deliberately does not claim full chain-tip freshness. It answers the
63/// narrower browser question: whether catching up to the target can expose a
64/// newer committed name-tree root. Unknown heights and genesis remain
65/// fail-closed.
66#[derive(Clone, Copy, Debug, Eq, PartialEq)]
67pub struct NameTreeCurrentness {
68    network: Network,
69    local_header_height: Option<u32>,
70    target_header_height: Option<u32>,
71    local_authority_height: Option<u32>,
72    target_authority_height: Option<u32>,
73    blocks_until_authority: Option<u32>,
74    ready: bool,
75}
76
77impl NameTreeCurrentness {
78    /// Assess whether the local validated chain contains the name-tree root
79    /// authoritative at the independently corroborated target height.
80    #[must_use]
81    pub const fn assess(
82        network: Network,
83        local_header_height: Option<u32>,
84        target_header_height: Option<u32>,
85    ) -> Self {
86        let local_authority_height = match local_header_height {
87            Some(height) if height > 0 => Some(name_tree_authority_height(network, height)),
88            _ => None,
89        };
90        let target_authority_height = match target_header_height {
91            Some(height) if height > 0 => Some(name_tree_authority_height(network, height)),
92            _ => None,
93        };
94        let ready = match (local_authority_height, target_authority_height) {
95            (Some(local), Some(target)) => local >= target,
96            _ => false,
97        };
98        let blocks_until_authority = match (ready, local_header_height, target_authority_height) {
99            (true, Some(_), Some(_)) => Some(0),
100            (false, Some(local), Some(target)) => Some(target.saturating_sub(local)),
101            _ => None,
102        };
103        Self {
104            network,
105            local_header_height,
106            target_header_height,
107            local_authority_height,
108            target_authority_height,
109            blocks_until_authority,
110            ready,
111        }
112    }
113
114    /// Selected Handshake network.
115    #[must_use]
116    pub const fn network(self) -> Network {
117        self.network
118    }
119
120    /// Local validated header height, when available.
121    #[must_use]
122    pub const fn local_header_height(self) -> Option<u32> {
123        self.local_header_height
124    }
125
126    /// Independently corroborated target height, when available.
127    #[must_use]
128    pub const fn target_header_height(self) -> Option<u32> {
129        self.target_header_height
130    }
131
132    /// Header that introduced the local authoritative name-tree root.
133    #[must_use]
134    pub const fn local_authority_height(self) -> Option<u32> {
135        self.local_authority_height
136    }
137
138    /// Header that introduced the target authoritative name-tree root.
139    #[must_use]
140    pub const fn target_authority_height(self) -> Option<u32> {
141        self.target_authority_height
142    }
143
144    /// Validated headers still required before the target authority is local.
145    #[must_use]
146    pub const fn blocks_until_authority(self) -> Option<u32> {
147        self.blocks_until_authority
148    }
149
150    /// Whether local state contains the target's authoritative name-tree root.
151    #[must_use]
152    pub const fn is_ready(self) -> bool {
153        self.ready
154    }
155}
156/// Current effective-runtime-feature schema.
157pub const RUNTIME_FEATURE_SCHEMA_VERSION: u16 = 1;
158
159/// Effective state for one browser runtime feature.
160///
161/// `observed` is request-scoped: `None` means no request observation was
162/// supplied, rather than claiming that the feature was or was not exercised.
163#[derive(Clone, Copy, Debug, Eq, PartialEq)]
164pub struct RuntimeFeatureState {
165    compiled: bool,
166    configured: bool,
167    active: bool,
168    observed: Option<bool>,
169}
170
171impl RuntimeFeatureState {
172    /// Construct and validate an effective feature state.
173    pub fn try_new(
174        compiled: bool,
175        configured: bool,
176        active: bool,
177        observed: Option<bool>,
178    ) -> Result<Self, RuntimeFeatureStateError> {
179        if configured && !compiled {
180            return Err(RuntimeFeatureStateError::ConfiguredWithoutCapability);
181        }
182        if active && !configured {
183            return Err(RuntimeFeatureStateError::ActiveWithoutConfiguration);
184        }
185        if observed == Some(true) && !active {
186            return Err(RuntimeFeatureStateError::ObservedWithoutActivePath);
187        }
188        Ok(Self {
189            compiled,
190            configured,
191            active,
192            observed,
193        })
194    }
195
196    /// Capability is absent from this binary.
197    #[must_use]
198    pub const fn not_compiled() -> Self {
199        Self {
200            compiled: false,
201            configured: false,
202            active: false,
203            observed: None,
204        }
205    }
206
207    /// Capability is compiled but disabled by effective policy.
208    #[must_use]
209    pub const fn compiled_disabled() -> Self {
210        Self {
211            compiled: true,
212            configured: false,
213            active: false,
214            observed: None,
215        }
216    }
217
218    /// Capability is configured but is not wired into the current path.
219    #[must_use]
220    pub const fn configured_inactive() -> Self {
221        Self {
222            compiled: true,
223            configured: true,
224            active: false,
225            observed: None,
226        }
227    }
228
229    /// Capability is configured and wired into the current path.
230    #[must_use]
231    pub const fn active(observed: Option<bool>) -> Self {
232        Self {
233            compiled: true,
234            configured: true,
235            active: true,
236            observed,
237        }
238    }
239
240    /// Whether this binary contains the capability.
241    #[must_use]
242    pub const fn is_compiled(self) -> bool {
243        self.compiled
244    }
245
246    /// Whether current policy enables the capability.
247    #[must_use]
248    pub const fn is_configured(self) -> bool {
249        self.configured
250    }
251
252    /// Whether the current production path wires the capability.
253    #[must_use]
254    pub const fn is_active(self) -> bool {
255        self.active
256    }
257
258    /// Request-scoped observation, or no value without request context.
259    #[must_use]
260    pub const fn observed(self) -> Option<bool> {
261        self.observed
262    }
263}
264
265/// Stable validation errors for effective runtime feature state.
266#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
267pub enum RuntimeFeatureStateError {
268    /// Policy configured a capability that is absent from the binary.
269    #[error("runtime feature cannot be configured when it is not compiled")]
270    ConfiguredWithoutCapability,
271    /// The production path claimed an unconfigured capability.
272    #[error("runtime feature cannot be active when it is not configured")]
273    ActiveWithoutConfiguration,
274    /// Request diagnostics claimed use of an inactive production path.
275    #[error("runtime feature cannot be observed on an inactive path")]
276    ObservedWithoutActivePath,
277}
278
279/// Effective production wiring for browser transport and resolver features.
280#[derive(Clone, Copy, Debug, Eq, PartialEq)]
281pub struct RuntimeFeatureDiagnostics {
282    /// Persistent resolver cache.
283    pub resolver_cache: RuntimeFeatureState,
284    /// Origin connection pooling.
285    pub connection_pooling: RuntimeFeatureState,
286    /// TLS session resumption.
287    pub tls_resumption: RuntimeFeatureState,
288    /// HTTP/3 promotion from authenticated Alt-Svc advertisements.
289    pub http3_promotion: RuntimeFeatureState,
290}
291
292/// Provider lifecycle state.
293#[repr(u8)]
294#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
295pub enum ReadinessState {
296    /// Role is disabled by policy.
297    #[default]
298    Disabled = 0,
299    /// Role is starting but cannot yet accept work.
300    Starting = 1,
301    /// Role can accept bounded work.
302    Ready = 2,
303    /// Admission is temporarily rate limited.
304    RateLimited = 3,
305    /// A recoverable dependency is unavailable.
306    Degraded = 4,
307    /// A policy/runtime transition revoked the role.
308    Revoked = 5,
309}
310
311/// Readiness for every independently advertised provider role.
312#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
313pub struct ProviderReadiness {
314    /// HIP #76 DNS relay.
315    pub dns_relay: ReadinessState,
316    /// HIP #77 ODoH proxy.
317    pub odoh_proxy: ReadinessState,
318    /// HIP #77 ODoH target.
319    pub odoh_target: ReadinessState,
320    /// HNSR endpoint.
321    pub hnsr_endpoint: ReadinessState,
322    /// HNSR relay.
323    pub hnsr_relay: ReadinessState,
324    /// Experimental market gossip.
325    pub market_gossip: ReadinessState,
326}
327
328impl ProviderReadiness {
329    /// Construct starting/disabled readiness directly from persistent policy.
330    ///
331    /// Every enabled role begins in [`ReadinessState::Starting`]; every
332    /// disabled role remains [`ReadinessState::Disabled`]. Adapters can then
333    /// replace enabled fields with their observed ready, limited, degraded, or
334    /// revoked states.
335    #[must_use]
336    pub const fn from_policy(policy: PolicySnapshot) -> Self {
337        let config = policy.config();
338        Self {
339            dns_relay: initial_readiness(config.providers.dns_relay),
340            odoh_proxy: initial_readiness(config.providers.odoh_proxy),
341            odoh_target: initial_readiness(config.providers.odoh_target),
342            hnsr_endpoint: initial_readiness(config.hnsr.endpoint_enabled()),
343            hnsr_relay: initial_readiness(config.hnsr.relay_enabled()),
344            market_gossip: initial_readiness(config.providers.market_gossip),
345        }
346    }
347}
348
349const fn initial_readiness(enabled: bool) -> ReadinessState {
350    if enabled {
351        ReadinessState::Starting
352    } else {
353        ReadinessState::Disabled
354    }
355}
356
357/// Aggregated, name-free rate-limit status.
358#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
359pub struct RateLimitState {
360    /// Currently executing requests.
361    pub in_flight: u32,
362    /// Configured finite concurrency.
363    pub max_concurrency: u32,
364    /// Admitted requests in the current window.
365    pub window_requests: u64,
366    /// Configured finite requests per window.
367    pub window_limit: u64,
368    /// Lifetime rejected request count.
369    pub rejected_total: u64,
370    /// Whether new work is currently limited.
371    pub limited: bool,
372}
373
374impl RateLimitState {
375    fn validate(self) -> Result<(), StatusError> {
376        if (self.max_concurrency == 0) != (self.window_limit == 0) {
377            return Err(StatusError::InvalidRateLimit);
378        }
379        if self.max_concurrency == 0 {
380            if self.in_flight != 0 || self.window_requests != 0 || self.limited {
381                return Err(StatusError::InvalidRateLimit);
382            }
383            return Ok(());
384        }
385        if self.in_flight > self.max_concurrency || self.window_requests > self.window_limit {
386            return Err(StatusError::InvalidRateLimit);
387        }
388        let saturated =
389            self.in_flight == self.max_concurrency || self.window_requests == self.window_limit;
390        if self.limited != saturated {
391            return Err(StatusError::InvalidRateLimit);
392        }
393        Ok(())
394    }
395}
396
397/// Stable degraded-state reason.
398#[repr(u16)]
399#[derive(Clone, Copy, Debug, Eq, PartialEq)]
400pub enum DegradedReason {
401    /// Validated headers do not meet currency policy.
402    HeadersStale = 1,
403    /// Header synchronization has no usable peer.
404    HeaderSyncUnavailable = 2,
405    /// A current name proof could not be obtained.
406    ProofUnavailable = 3,
407    /// No policy-permitted DNS transport is ready.
408    ResolutionTransportUnavailable = 4,
409    /// Local DNSSEC validation failed.
410    DnssecFailure = 5,
411    /// A secure supported TLSA record is unavailable.
412    TlsaFailure = 6,
413    /// Local DANE origin validation failed.
414    DaneFailure = 7,
415    /// Platform browser bridge is unavailable.
416    BrowserBridgeUnavailable = 8,
417    /// An enabled provider dependency is unavailable.
418    ProviderUnavailable = 9,
419}
420
421/// Stable revocation reason.
422#[repr(u16)]
423#[derive(Clone, Copy, Debug, Eq, PartialEq)]
424pub enum RevocationReason {
425    /// Persistent policy changed.
426    PolicyChanged = 1,
427    /// Runtime session or generation changed.
428    RuntimeChanged = 2,
429    /// Handshake network changed.
430    NetworkChanged = 3,
431    /// Experimental registry profile or fingerprint changed.
432    RegistryChanged = 4,
433    /// Provider role was disabled.
434    ProviderDisabled = 5,
435    /// Runtime stopped.
436    Stopped = 6,
437}
438
439/// Evidence category that could not be evaluated.
440#[repr(u8)]
441#[derive(Clone, Copy, Debug, Eq, PartialEq)]
442pub enum EvidenceKind {
443    /// Handshake header/Urkel proof.
444    HnsProof = 0,
445    /// Chain currency.
446    ChainCurrency = 1,
447    /// DNSSEC.
448    Dnssec = 2,
449    /// TLSA.
450    Tlsa = 3,
451    /// DANE.
452    Dane = 4,
453    /// Origin SNI.
454    OriginSni = 5,
455    /// Experimental transport protocol.
456    TransportProtocol = 6,
457}
458
459/// Bounded unsupported-evidence detail.
460#[derive(Clone, Copy, Debug, Eq, PartialEq)]
461pub struct UnsupportedEvidence {
462    /// Evidence category.
463    pub kind: EvidenceKind,
464    /// Protocol algorithm, selector, usage, version, or local reason code.
465    pub code: u16,
466}
467
468/// Identity fields for the actually selected DNS transport.
469#[derive(Clone, Debug, Default, Eq, PartialEq)]
470pub struct TransportIdentities {
471    /// Relay or P2P peer.
472    pub peer: Option<String>,
473    /// ODoH proxy.
474    pub proxy: Option<String>,
475    /// ODoH target.
476    pub target: Option<String>,
477    /// Whether privacy policy allowed and used direct-relay fallback.
478    pub direct_relay_fallback: bool,
479}
480
481/// Name-free browser trust action for the ICANN TLS path.
482#[repr(u8)]
483#[derive(Clone, Copy, Debug, Eq, PartialEq)]
484pub enum IcannTlsAction {
485    /// Secure TLSA data is present and local DANE must be enforced.
486    EnforceDane = 1,
487    /// Secure authenticated denial permits WebPKI.
488    WebPkiAuthenticatedAbsence = 2,
489    /// A proven-insecure delegation permits WebPKI.
490    WebPkiInsecureDelegation = 3,
491    /// DNSSEC, resolver authentication, or TLSA/DANE evidence failed closed.
492    FailClosed = 4,
493}
494
495/// Inputs for one checked status snapshot.
496#[derive(Clone, Debug, Eq, PartialEq)]
497pub struct StatusInput {
498    /// One atomically read runtime tuple, including authority state.
499    pub runtime: RuntimeSnapshot,
500    /// Handshake network.
501    pub network: Network,
502    /// Current policy snapshot and generation.
503    pub policy: PolicySnapshot,
504    /// Current locally validated chain anchor.
505    pub chain_anchor: Option<ChainAnchor>,
506    /// Actual selected DNS transport, not the authoritative nameserver.
507    pub actual_transport: ResolutionTransport,
508    /// Actual intermediary identities.
509    pub identities: TransportIdentities,
510    /// Negotiated experimental registry profile.
511    pub registry_profile: WireProfile,
512    /// Exact canonical registry fingerprint.
513    pub registry_fingerprint: [u8; 32],
514    /// Negotiated protocol/status version.
515    pub protocol_version: u16,
516    /// Readiness of every provider role.
517    pub provider_readiness: ProviderReadiness,
518    /// Aggregate rate-limit state without qnames.
519    pub rate_limits: RateLimitState,
520    /// Current local validation evidence.
521    pub evidence: ValidationEvidence,
522    /// Full-host dual-root outcome kind, without the queried name or plans.
523    pub namespace_outcome: Option<OutcomeKind>,
524    /// Name-free HNS root lookup failure, when classification failed.
525    pub hns_root_failure: Option<RootFailureKind>,
526    /// Name-free ICANN root lookup failure, when classification failed.
527    pub icann_root_failure: Option<RootFailureKind>,
528    /// Namespace selected for the current decision.
529    pub selected_namespace: Option<Namespace>,
530    /// Stable reason for the namespace selection.
531    pub selection_reason: Option<SelectionReason>,
532    /// Name-free, query/policy/plan-bound namespace decision fingerprint.
533    pub decision_fingerprint: Option<[u8; 32]>,
534    /// Current ICANN DANE/WebPKI/fail-closed action.
535    ///
536    /// This may be `None` when no namespace decision exists or when the
537    /// selected origin scheme is intentionally cleartext.
538    pub icann_tls_action: Option<IcannTlsAction>,
539    /// Canonical validating-DoH DNSSEC disposition for the ICANN action.
540    pub icann_dnssec_status: Option<IcannDnssecStatus>,
541    /// Recoverable degraded reason.
542    pub degraded_reason: Option<DegradedReason>,
543    /// Revocation reason.
544    pub revocation_reason: Option<RevocationReason>,
545    /// Unsupported evidence details.
546    pub unsupported_evidence: Vec<UnsupportedEvidence>,
547}
548
549/// Checked, immutable browser security status.
550#[derive(Clone, Debug, Eq, PartialEq)]
551pub struct BrowserStatus {
552    input: StatusInput,
553}
554
555impl BrowserStatus {
556    /// Validate all cross-field invariants and construct one snapshot.
557    pub fn new(input: StatusInput) -> Result<Self, StatusError> {
558        if input.runtime.schema_version() != RUNTIME_SCHEMA_VERSION
559            || input.runtime.generation() == 0
560            || input.policy.generation() == 0
561        {
562            return Err(StatusError::InvalidGeneration);
563        }
564        validate_identities(input.actual_transport, &input.identities)?;
565        validate_provider_readiness(
566            input.policy.config().providers,
567            input.policy.config().hnsr,
568            input.provider_readiness,
569        )?;
570        input.rate_limits.validate()?;
571        if input.unsupported_evidence.len() > MAX_UNSUPPORTED_EVIDENCE {
572            return Err(StatusError::UnsupportedEvidenceLimit);
573        }
574        if matches!(
575            input.evidence.hns_proof,
576            hns_resolution_policy::EvidenceState::Verified
577        ) && input.chain_anchor.is_none()
578        {
579            return Err(StatusError::MissingChainAnchor);
580        }
581        if input.evidence.fully_verified()
582            && input.actual_transport == ResolutionTransport::Unavailable
583        {
584            return Err(StatusError::VerifiedWithoutTransport);
585        }
586        if is_experimental_p2p(input.actual_transport) {
587            if input.registry_fingerprint == [0; 32] || input.protocol_version == 0 {
588                return Err(StatusError::MissingProtocolIdentity);
589            }
590        } else if input.registry_fingerprint != [0; 32] || input.protocol_version != 0 {
591            return Err(StatusError::UnexpectedProtocolIdentity);
592        }
593        validate_failure_reasons(
594            input.runtime.authority_state(),
595            input.degraded_reason,
596            input.revocation_reason,
597        )?;
598        validate_namespace_context(&input)?;
599        validate_icann_tls_context(
600            input.selected_namespace == Some(Namespace::Icann),
601            input.icann_root_failure,
602            input.icann_tls_action,
603            input.icann_dnssec_status,
604            input.evidence,
605        )?;
606        Ok(Self { input })
607    }
608
609    /// Shared schema version.
610    #[must_use]
611    pub const fn schema_version(&self) -> u16 {
612        STATUS_SCHEMA_VERSION
613    }
614
615    /// Runtime session.
616    #[must_use]
617    pub const fn runtime_session(&self) -> [u8; 16] {
618        self.input.runtime.session_bytes()
619    }
620
621    /// Runtime generation.
622    #[must_use]
623    pub const fn runtime_generation(&self) -> u64 {
624        self.input.runtime.generation()
625    }
626
627    /// Policy generation.
628    #[must_use]
629    pub const fn policy_generation(&self) -> u64 {
630        self.input.policy.generation()
631    }
632
633    /// Event sequence.
634    #[must_use]
635    pub const fn event_sequence(&self) -> u64 {
636        self.input.runtime.event_sequence()
637    }
638
639    /// Atomically bound runtime tuple used to construct this status.
640    #[must_use]
641    pub const fn runtime_snapshot(&self) -> RuntimeSnapshot {
642        self.input.runtime
643    }
644
645    /// Current browser authority state.
646    #[must_use]
647    pub const fn authority_state(&self) -> AuthorityState {
648        self.input.runtime.authority_state()
649    }
650
651    /// Handshake network.
652    #[must_use]
653    pub const fn network(&self) -> Network {
654        self.input.network
655    }
656
657    /// Validated chain anchor.
658    #[must_use]
659    pub const fn chain_anchor(&self) -> Option<ChainAnchor> {
660        self.input.chain_anchor
661    }
662
663    /// Complete current transport policy.
664    #[must_use]
665    pub const fn transport_policy(&self) -> PolicySnapshot {
666        self.input.policy
667    }
668
669    /// Actually selected transport.
670    #[must_use]
671    pub const fn actual_transport(&self) -> ResolutionTransport {
672        self.input.actual_transport
673    }
674
675    /// Actual intermediary identities.
676    #[must_use]
677    pub const fn identities(&self) -> &TransportIdentities {
678        &self.input.identities
679    }
680
681    /// Registry profile.
682    #[must_use]
683    pub const fn registry_profile(&self) -> WireProfile {
684        self.input.registry_profile
685    }
686
687    /// Canonical registry fingerprint.
688    #[must_use]
689    pub const fn registry_fingerprint(&self) -> [u8; 32] {
690        self.input.registry_fingerprint
691    }
692
693    /// Negotiated protocol version.
694    #[must_use]
695    pub const fn protocol_version(&self) -> u16 {
696        self.input.protocol_version
697    }
698
699    /// Explicit HNSR mode.
700    #[must_use]
701    pub const fn hnsr_mode(&self) -> HnsrPolicy {
702        self.input.policy.config().hnsr
703    }
704
705    /// Explicit provider roles.
706    #[must_use]
707    pub const fn provider_roles(&self) -> ProviderPolicy {
708        self.input.policy.config().providers
709    }
710
711    /// Provider readiness.
712    #[must_use]
713    pub const fn provider_readiness(&self) -> ProviderReadiness {
714        self.input.provider_readiness
715    }
716
717    /// Aggregate rate-limit state.
718    #[must_use]
719    pub const fn rate_limits(&self) -> RateLimitState {
720        self.input.rate_limits
721    }
722
723    /// Local evidence states.
724    #[must_use]
725    pub const fn evidence(&self) -> ValidationEvidence {
726        self.input.evidence
727    }
728
729    /// Full-host dual-root outcome kind.
730    #[must_use]
731    pub const fn namespace_outcome(&self) -> Option<OutcomeKind> {
732        self.input.namespace_outcome
733    }
734
735    /// Name-free HNS root lookup failure.
736    #[must_use]
737    pub const fn hns_root_failure(&self) -> Option<RootFailureKind> {
738        self.input.hns_root_failure
739    }
740
741    /// Name-free ICANN root lookup failure.
742    #[must_use]
743    pub const fn icann_root_failure(&self) -> Option<RootFailureKind> {
744        self.input.icann_root_failure
745    }
746
747    /// Namespace selected by the current decision.
748    #[must_use]
749    pub const fn selected_namespace(&self) -> Option<Namespace> {
750        self.input.selected_namespace
751    }
752
753    /// Stable namespace-selection reason.
754    #[must_use]
755    pub const fn selection_reason(&self) -> Option<SelectionReason> {
756        self.input.selection_reason
757    }
758
759    /// Name-free namespace decision fingerprint.
760    #[must_use]
761    pub const fn decision_fingerprint(&self) -> Option<[u8; 32]> {
762        self.input.decision_fingerprint
763    }
764
765    /// Current ICANN TLS action.
766    #[must_use]
767    pub const fn icann_tls_action(&self) -> Option<IcannTlsAction> {
768        self.input.icann_tls_action
769    }
770
771    /// Canonical validating-DoH DNSSEC disposition for the ICANN action.
772    #[must_use]
773    pub const fn icann_dnssec_status(&self) -> Option<IcannDnssecStatus> {
774        self.input.icann_dnssec_status
775    }
776
777    /// Current degraded reason.
778    #[must_use]
779    pub const fn degraded_reason(&self) -> Option<DegradedReason> {
780        self.input.degraded_reason
781    }
782
783    /// Current revocation reason.
784    #[must_use]
785    pub const fn revocation_reason(&self) -> Option<RevocationReason> {
786        self.input.revocation_reason
787    }
788
789    /// Unsupported evidence details.
790    #[must_use]
791    pub fn unsupported_evidence(&self) -> &[UnsupportedEvidence] {
792        &self.input.unsupported_evidence
793    }
794}
795
796const fn is_experimental_p2p(transport: ResolutionTransport) -> bool {
797    matches!(
798        transport,
799        ResolutionTransport::HandshakeP2pOdoh | ResolutionTransport::HandshakeP2pDnsRelay
800    )
801}
802
803fn validate_failure_reasons(
804    authority: AuthorityState,
805    degraded: Option<DegradedReason>,
806    revoked: Option<RevocationReason>,
807) -> Result<(), StatusError> {
808    if degraded.is_some() && revoked.is_some() {
809        return Err(StatusError::ConflictingFailureReasons);
810    }
811    match authority {
812        AuthorityState::Degraded => {
813            if degraded.is_none() {
814                return Err(StatusError::MissingFailureReason);
815            }
816        }
817        AuthorityState::Revoked => {
818            if revoked.is_none() {
819                return Err(StatusError::MissingFailureReason);
820            }
821            if revoked == Some(RevocationReason::Stopped) {
822                return Err(StatusError::FailureReasonMismatch);
823            }
824        }
825        AuthorityState::Stopped => {
826            if revoked.is_none() {
827                return Err(StatusError::MissingFailureReason);
828            }
829            if revoked != Some(RevocationReason::Stopped) {
830                return Err(StatusError::FailureReasonMismatch);
831            }
832        }
833        AuthorityState::Uninitialized
834        | AuthorityState::LocalStateOpened
835        | AuthorityState::HeaderSyncing
836        | AuthorityState::HeaderCurrent
837        | AuthorityState::ProofReady
838        | AuthorityState::ResolutionTransportReady
839        | AuthorityState::DnssecVerified
840        | AuthorityState::DaneOriginVerified
841        | AuthorityState::BrowserBridgeReady
842        | AuthorityState::Active => {
843            if degraded.is_some() || revoked.is_some() {
844                return Err(StatusError::FailureReasonMismatch);
845            }
846        }
847    }
848    Ok(())
849}
850
851fn validate_namespace_context(input: &StatusInput) -> Result<(), StatusError> {
852    if input.decision_fingerprint == Some([0; 32]) {
853        return Err(StatusError::InvalidDecisionFingerprint);
854    }
855    if input.namespace_outcome.is_some()
856        && (input.hns_root_failure.is_some() || input.icann_root_failure.is_some())
857    {
858        return Err(StatusError::InvalidNamespaceContext);
859    }
860
861    match input.namespace_outcome {
862        None => {
863            if input.selected_namespace.is_some()
864                || input.selection_reason.is_some()
865                || input.decision_fingerprint.is_some()
866            {
867                return Err(StatusError::InvalidNamespaceContext);
868            }
869        }
870        Some(OutcomeKind::Neither) => {
871            if input.selected_namespace.is_some()
872                || input.selection_reason.is_some()
873                || input.decision_fingerprint.is_none()
874                || input.actual_transport != ResolutionTransport::Unavailable
875            {
876                return Err(StatusError::InvalidNamespaceContext);
877            }
878        }
879        Some(OutcomeKind::HnsOnly) => {
880            if input.selected_namespace != Some(Namespace::Hns)
881                || input.selection_reason.is_none()
882                || input.decision_fingerprint.is_none()
883            {
884                return Err(StatusError::InvalidNamespaceContext);
885            }
886        }
887        Some(OutcomeKind::IcannOnly) => {
888            if input.selected_namespace != Some(Namespace::Icann)
889                || input.selection_reason.is_none()
890                || input.decision_fingerprint.is_none()
891            {
892                return Err(StatusError::InvalidNamespaceContext);
893            }
894        }
895        Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent) => {
896            if input.selected_namespace.is_none()
897                || input.selection_reason.is_none()
898                || input.decision_fingerprint.is_none()
899            {
900                return Err(StatusError::InvalidNamespaceContext);
901            }
902        }
903    }
904    if !valid_namespace_selection(
905        input.namespace_outcome,
906        input.selected_namespace,
907        input.selection_reason,
908    ) {
909        return Err(StatusError::InvalidNamespaceContext);
910    }
911
912    let selected_icann = input.selected_namespace == Some(Namespace::Icann);
913    let failed_icann = input.icann_root_failure.is_some();
914    let failed_hns_only = input.hns_root_failure.is_some() && !failed_icann;
915    let used_icann_doh = input.actual_transport == ResolutionTransport::ValidatingIcannDoh;
916    if selected_icann && !used_icann_doh {
917        return Err(StatusError::InvalidIcannTlsContext);
918    }
919    if failed_icann && !used_icann_doh {
920        return Err(StatusError::InvalidIcannTlsContext);
921    }
922    if failed_hns_only && input.actual_transport != ResolutionTransport::Unavailable {
923        return Err(StatusError::InvalidNamespaceContext);
924    }
925    if used_icann_doh && !selected_icann && !failed_icann {
926        return Err(StatusError::InvalidIcannTlsContext);
927    }
928    if !selected_icann
929        && !failed_icann
930        && (input.icann_tls_action.is_some() || input.icann_dnssec_status.is_some())
931    {
932        return Err(StatusError::InvalidIcannTlsContext);
933    }
934    if failed_icann && input.icann_tls_action != Some(IcannTlsAction::FailClosed) {
935        return Err(StatusError::InvalidIcannTlsContext);
936    }
937    Ok(())
938}
939
940fn validate_icann_tls_context(
941    selected_icann: bool,
942    root_failure: Option<RootFailureKind>,
943    action: Option<IcannTlsAction>,
944    dnssec_status: Option<IcannDnssecStatus>,
945    evidence: ValidationEvidence,
946) -> Result<(), StatusError> {
947    use hns_resolution_policy::EvidenceState::{NotAttempted, Unavailable, Verified};
948
949    let dane =
950        evidence.dnssec == Verified && evidence.tlsa == Verified && evidence.dane == Verified;
951    let webpki = evidence.dnssec == Verified
952        && evidence.tlsa == Unavailable
953        && matches!(evidence.dane, NotAttempted | Unavailable);
954
955    let valid = match action {
956        None if selected_icann => {
957            evidence.dnssec == Verified
958                && evidence.tlsa == NotAttempted
959                && evidence.dane == NotAttempted
960                && matches!(
961                    dnssec_status,
962                    Some(IcannDnssecStatus::Secure | IcannDnssecStatus::InsecureDelegation)
963                )
964        }
965        None => root_failure.is_none() && dnssec_status.is_none(),
966        Some(IcannTlsAction::EnforceDane) => {
967            selected_icann && dnssec_status == Some(IcannDnssecStatus::Secure) && dane
968        }
969        Some(IcannTlsAction::WebPkiAuthenticatedAbsence) => {
970            selected_icann && dnssec_status == Some(IcannDnssecStatus::Secure) && webpki
971        }
972        Some(IcannTlsAction::WebPkiInsecureDelegation) => {
973            selected_icann && dnssec_status == Some(IcannDnssecStatus::InsecureDelegation) && webpki
974        }
975        Some(IcannTlsAction::FailClosed) if root_failure.is_some() => {
976            validate_icann_failure_context(root_failure, dnssec_status, evidence)
977                && !dane
978                && !webpki
979        }
980        Some(IcannTlsAction::FailClosed) => {
981            selected_icann
982                && matches!(
983                    dnssec_status,
984                    Some(IcannDnssecStatus::Secure | IcannDnssecStatus::InsecureDelegation)
985                )
986                && evidence.dnssec == Verified
987                && !dane
988                && !webpki
989        }
990    };
991    if valid {
992        Ok(())
993    } else {
994        Err(StatusError::InvalidIcannTlsContext)
995    }
996}
997
998fn validate_icann_failure_context(
999    root_failure: Option<RootFailureKind>,
1000    dnssec_status: Option<IcannDnssecStatus>,
1001    evidence: ValidationEvidence,
1002) -> bool {
1003    use hns_resolution_policy::EvidenceState::{Failed, NotAttempted, Unavailable};
1004
1005    match root_failure {
1006        Some(RootFailureKind::BogusDnssec) => {
1007            dnssec_status == Some(IcannDnssecStatus::Bogus) && evidence.dnssec == Failed
1008        }
1009        Some(RootFailureKind::IndeterminateDnssec) => {
1010            dnssec_status == Some(IcannDnssecStatus::Indeterminate)
1011                && matches!(evidence.dnssec, NotAttempted | Unavailable)
1012        }
1013        Some(
1014            RootFailureKind::Timeout
1015            | RootFailureKind::Transport
1016            | RootFailureKind::UnauthenticatedResolver
1017            | RootFailureKind::MalformedResponse
1018            | RootFailureKind::Unsupported
1019            | RootFailureKind::Cancelled
1020            | RootFailureKind::Internal
1021            | RootFailureKind::StaleEvidence,
1022        ) => {
1023            dnssec_status.is_none()
1024                && evidence.dnssec != hns_resolution_policy::EvidenceState::Verified
1025        }
1026        Some(RootFailureKind::StaleHnsAnchor) | None => false,
1027    }
1028}
1029
1030const fn valid_namespace_selection(
1031    outcome: Option<OutcomeKind>,
1032    selected: Option<Namespace>,
1033    reason: Option<SelectionReason>,
1034) -> bool {
1035    matches!(
1036        (outcome, selected, reason),
1037        (None | Some(OutcomeKind::Neither), None, None)
1038            | (
1039                Some(OutcomeKind::HnsOnly),
1040                Some(Namespace::Hns),
1041                Some(
1042                    SelectionReason::SingleRoot
1043                        | SelectionReason::ExplicitPin
1044                        | SelectionReason::StickyBinding,
1045                ),
1046            )
1047            | (
1048                Some(OutcomeKind::IcannOnly),
1049                Some(Namespace::Icann),
1050                Some(
1051                    SelectionReason::SingleRoot
1052                        | SelectionReason::ExplicitPin
1053                        | SelectionReason::StickyBinding,
1054                ),
1055            )
1056            | (
1057                Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent),
1058                Some(Namespace::Hns),
1059                Some(SelectionReason::ExplicitPin | SelectionReason::StickyBinding),
1060            )
1061            | (
1062                Some(OutcomeKind::BothConvergent | OutcomeKind::BothDivergent),
1063                Some(Namespace::Icann),
1064                Some(
1065                    SelectionReason::ExplicitPin
1066                        | SelectionReason::StickyBinding
1067                        | SelectionReason::IcannDefault,
1068                ),
1069            )
1070    )
1071}
1072
1073fn validate_identities(
1074    transport: ResolutionTransport,
1075    identities: &TransportIdentities,
1076) -> Result<(), StatusError> {
1077    for identity in [
1078        identities.peer.as_deref(),
1079        identities.proxy.as_deref(),
1080        identities.target.as_deref(),
1081    ]
1082    .into_iter()
1083    .flatten()
1084    {
1085        if identity.is_empty() || identity.len() > MAX_IDENTITY_BYTES {
1086            return Err(StatusError::InvalidIdentity);
1087        }
1088    }
1089    match transport {
1090        ResolutionTransport::HandshakeP2pOdoh => {
1091            let proxy = identities
1092                .proxy
1093                .as_deref()
1094                .ok_or(StatusError::MissingIdentity)?;
1095            let target = identities
1096                .target
1097                .as_deref()
1098                .ok_or(StatusError::MissingIdentity)?;
1099            if proxy == target || identities.peer.is_some() || identities.direct_relay_fallback {
1100                return Err(StatusError::InvalidTransportContext);
1101            }
1102        }
1103        ResolutionTransport::HandshakeP2pDnsRelay => {
1104            if identities.peer.is_none()
1105                || identities.proxy.is_some()
1106                || identities.target.is_some()
1107            {
1108                return Err(StatusError::InvalidTransportContext);
1109            }
1110        }
1111        ResolutionTransport::DirectAuthoritativeUdp
1112        | ResolutionTransport::DirectAuthoritativeTcp
1113        | ResolutionTransport::AuthenticatedAuthoritativeDoh
1114        | ResolutionTransport::ValidatingIcannDoh
1115        | ResolutionTransport::UserConfiguredRecursiveHnsDoh
1116        | ResolutionTransport::LocalHnsProof => {
1117            if identities.peer.is_some()
1118                || identities.proxy.is_some()
1119                || identities.target.is_some()
1120                || identities.direct_relay_fallback
1121            {
1122                return Err(StatusError::InvalidTransportContext);
1123            }
1124        }
1125        ResolutionTransport::Unavailable => {
1126            if identities != &TransportIdentities::default() {
1127                return Err(StatusError::InvalidTransportContext);
1128            }
1129        }
1130    }
1131    Ok(())
1132}
1133
1134fn validate_provider_readiness(
1135    roles: ProviderPolicy,
1136    hnsr: HnsrPolicy,
1137    readiness: ProviderReadiness,
1138) -> Result<(), StatusError> {
1139    let endpoint_enabled = hnsr.endpoint_enabled();
1140    let relay_enabled = hnsr.relay_enabled();
1141    for (enabled, state) in [
1142        (roles.dns_relay, readiness.dns_relay),
1143        (roles.odoh_proxy, readiness.odoh_proxy),
1144        (roles.odoh_target, readiness.odoh_target),
1145        (endpoint_enabled, readiness.hnsr_endpoint),
1146        (relay_enabled, readiness.hnsr_relay),
1147        (roles.market_gossip, readiness.market_gossip),
1148    ] {
1149        if !enabled && !matches!(state, ReadinessState::Disabled | ReadinessState::Revoked) {
1150            return Err(StatusError::InvalidProviderReadiness);
1151        }
1152        if enabled && state == ReadinessState::Disabled {
1153            return Err(StatusError::InvalidProviderReadiness);
1154        }
1155    }
1156    Ok(())
1157}
1158
1159/// Invalid status or cross-field inconsistency.
1160#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
1161#[non_exhaustive]
1162pub enum StatusError {
1163    /// A runtime or policy generation is invalid.
1164    #[error("invalid status generation")]
1165    InvalidGeneration,
1166    /// An identity is empty or exceeds its byte bound.
1167    #[error("invalid transport identity")]
1168    InvalidIdentity,
1169    /// The selected transport requires an absent identity.
1170    #[error("missing transport identity")]
1171    MissingIdentity,
1172    /// Identity/fallback fields conflict with the actual transport.
1173    #[error("invalid actual-transport context")]
1174    InvalidTransportContext,
1175    /// Provider readiness conflicts with explicit provider policy.
1176    #[error("provider readiness conflicts with provider roles")]
1177    InvalidProviderReadiness,
1178    /// Rate-limit counters or saturation state are inconsistent.
1179    #[error("invalid rate-limit state")]
1180    InvalidRateLimit,
1181    /// Too many unsupported-evidence details were supplied.
1182    #[error("unsupported-evidence detail bound exceeded")]
1183    UnsupportedEvidenceLimit,
1184    /// Verified HNS proof state has no chain anchor.
1185    #[error("verified HNS evidence has no chain anchor")]
1186    MissingChainAnchor,
1187    /// Complete verified evidence cannot have an unavailable transport.
1188    #[error("verified result has no actual transport")]
1189    VerifiedWithoutTransport,
1190    /// Experimental P2P transport lacks registry fingerprint or protocol.
1191    #[error("experimental P2P transport has no protocol identity")]
1192    MissingProtocolIdentity,
1193    /// A non-P2P transport carried experimental registry identity.
1194    #[error("non-P2P transport carries experimental protocol identity")]
1195    UnexpectedProtocolIdentity,
1196    /// Degraded and revoked reasons cannot both be current.
1197    #[error("status is both degraded and revoked")]
1198    ConflictingFailureReasons,
1199    /// Degraded, revoked, or stopped authority omitted its required reason.
1200    #[error("authority state requires a failure reason")]
1201    MissingFailureReason,
1202    /// A failure reason conflicts with the current authority state.
1203    #[error("failure reason conflicts with authority state")]
1204    FailureReasonMismatch,
1205    /// Namespace outcome, selection, reason, and fingerprint are inconsistent.
1206    #[error("invalid name-free namespace decision context")]
1207    InvalidNamespaceContext,
1208    /// A present decision fingerprint cannot use the all-zero sentinel.
1209    #[error("invalid namespace decision fingerprint")]
1210    InvalidDecisionFingerprint,
1211    /// ICANN TLS action conflicts with the explicit evidence states.
1212    #[error("ICANN TLS action conflicts with validation evidence")]
1213    InvalidIcannTlsContext,
1214}
1215
1216#[cfg(test)]
1217#[allow(
1218    clippy::unwrap_used,
1219    reason = "tests fail immediately when a locally constructed status fixture is invalid"
1220)]
1221mod tests {
1222    use hns_browser_runtime::{BrowserRuntime, RuntimeSessionId};
1223    use hns_resolution_policy::{
1224        DnsRelayRequesterPolicy, EvidenceState, HnsrPolicy, ObliviousDnsPolicy, PolicyConfig,
1225        ProviderPolicy, ValidationEvidence,
1226    };
1227
1228    use super::*;
1229
1230    fn policy() -> PolicySnapshot {
1231        PolicySnapshot::new(
1232            7,
1233            PolicyConfig {
1234                dns_relay_requester: DnsRelayRequesterPolicy::Auto,
1235                oblivious_dns: ObliviousDnsPolicy::Preferred,
1236                hnsr: HnsrPolicy::disabled().with_endpoint(true),
1237                authenticated_authoritative_doh: true,
1238                user_configured_recursive_hns_doh: false,
1239                providers: ProviderPolicy {
1240                    dns_relay: true,
1241                    odoh_proxy: false,
1242                    odoh_target: false,
1243                    market_gossip: false,
1244                },
1245                wire_profile: WireProfile::ShakescapeV1,
1246                allow_legacy_regtest_compatibility: false,
1247            },
1248        )
1249        .unwrap()
1250    }
1251
1252    fn active_runtime(session_byte: u8, dane_applies: bool) -> RuntimeSnapshot {
1253        let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([session_byte; 16]).unwrap());
1254        for state in [
1255            AuthorityState::LocalStateOpened,
1256            AuthorityState::HeaderSyncing,
1257            AuthorityState::HeaderCurrent,
1258            AuthorityState::ProofReady,
1259            AuthorityState::ResolutionTransportReady,
1260            AuthorityState::DnssecVerified,
1261        ] {
1262            runtime.transition(state).unwrap();
1263        }
1264        if dane_applies {
1265            runtime
1266                .transition(AuthorityState::DaneOriginVerified)
1267                .unwrap();
1268        }
1269        runtime
1270            .transition(AuthorityState::BrowserBridgeReady)
1271            .unwrap();
1272        runtime.transition(AuthorityState::Active).unwrap();
1273        runtime.snapshot()
1274    }
1275
1276    fn input() -> StatusInput {
1277        let policy = policy();
1278        let mut provider_readiness = ProviderReadiness::from_policy(policy);
1279        provider_readiness.dns_relay = ReadinessState::Ready;
1280        StatusInput {
1281            runtime: active_runtime(7, true),
1282            network: Network::Mainnet,
1283            policy,
1284            chain_anchor: Some(ChainAnchor {
1285                height: 123,
1286                tree_root: [4; 32],
1287            }),
1288            actual_transport: ResolutionTransport::HandshakeP2pDnsRelay,
1289            identities: TransportIdentities {
1290                peer: Some("peer-a".to_owned()),
1291                ..TransportIdentities::default()
1292            },
1293            registry_profile: WireProfile::ShakescapeV1,
1294            registry_fingerprint: [8; 32],
1295            protocol_version: 1,
1296            provider_readiness,
1297            rate_limits: RateLimitState {
1298                in_flight: 2,
1299                max_concurrency: 8,
1300                window_requests: 5,
1301                window_limit: 10,
1302                rejected_total: 1,
1303                limited: false,
1304            },
1305            evidence: ValidationEvidence {
1306                hns_proof: EvidenceState::Verified,
1307                dnssec: EvidenceState::Verified,
1308                tlsa: EvidenceState::Verified,
1309                dane: EvidenceState::Verified,
1310                chain_current: EvidenceState::Verified,
1311                origin_sni: EvidenceState::Verified,
1312            },
1313            namespace_outcome: None,
1314            hns_root_failure: None,
1315            icann_root_failure: None,
1316            selected_namespace: None,
1317            selection_reason: None,
1318            decision_fingerprint: None,
1319            icann_tls_action: None,
1320            icann_dnssec_status: None,
1321            degraded_reason: None,
1322            revocation_reason: None,
1323            unsupported_evidence: Vec::new(),
1324        }
1325    }
1326
1327    #[test]
1328    fn exposes_every_required_status_dimension() {
1329        let status = BrowserStatus::new(input()).unwrap();
1330        assert_eq!(status.schema_version(), 2);
1331        assert_eq!(status.authority_state(), AuthorityState::Active);
1332        assert_eq!(status.policy_generation(), 7);
1333        assert_eq!(
1334            status.actual_transport(),
1335            ResolutionTransport::HandshakeP2pDnsRelay
1336        );
1337        assert_eq!(status.identities().peer.as_deref(), Some("peer-a"));
1338        assert_eq!(
1339            status.hnsr_mode(),
1340            HnsrPolicy::disabled().with_endpoint(true)
1341        );
1342        assert!(status.provider_roles().dns_relay);
1343        assert_eq!(status.provider_readiness().dns_relay, ReadinessState::Ready);
1344        assert!(status.evidence().fully_verified());
1345    }
1346
1347    #[test]
1348    fn runtime_tuple_is_bound_as_one_snapshot() {
1349        let input = input();
1350        let expected = input.runtime;
1351        let status = BrowserStatus::new(input).unwrap();
1352        assert_eq!(status.runtime_snapshot(), expected);
1353        assert_eq!(status.runtime_session(), expected.session_bytes());
1354        assert_eq!(status.runtime_generation(), expected.generation());
1355        assert_eq!(status.event_sequence(), expected.event_sequence());
1356        assert_eq!(status.authority_state(), expected.authority_state());
1357    }
1358
1359    #[test]
1360    fn p2p_transport_identity_and_protocol_context_fail_closed() {
1361        let mut status = input();
1362        status.actual_transport = ResolutionTransport::HandshakeP2pOdoh;
1363        assert_eq!(
1364            BrowserStatus::new(status.clone()),
1365            Err(StatusError::MissingIdentity)
1366        );
1367        status.identities = TransportIdentities {
1368            proxy: Some("same".to_owned()),
1369            target: Some("same".to_owned()),
1370            ..TransportIdentities::default()
1371        };
1372        assert_eq!(
1373            BrowserStatus::new(status),
1374            Err(StatusError::InvalidTransportContext)
1375        );
1376
1377        let mut status = input();
1378        status.registry_fingerprint = [0; 32];
1379        assert_eq!(
1380            BrowserStatus::new(status),
1381            Err(StatusError::MissingProtocolIdentity)
1382        );
1383    }
1384
1385    #[test]
1386    fn registry_identity_is_present_exactly_for_p2p_transport() {
1387        let mut status = input();
1388        status.actual_transport = ResolutionTransport::DirectAuthoritativeTcp;
1389        status.identities = TransportIdentities::default();
1390        assert_eq!(
1391            BrowserStatus::new(status.clone()),
1392            Err(StatusError::UnexpectedProtocolIdentity)
1393        );
1394        status.registry_fingerprint = [0; 32];
1395        status.protocol_version = 0;
1396        let status = BrowserStatus::new(status).unwrap();
1397        assert_eq!(
1398            status.actual_transport(),
1399            ResolutionTransport::DirectAuthoritativeTcp
1400        );
1401        assert_eq!(status.registry_fingerprint(), [0; 32]);
1402        assert_eq!(status.protocol_version(), 0);
1403    }
1404
1405    #[test]
1406    fn user_configured_recursive_hns_doh_is_non_p2p_status_provenance() {
1407        let mut status = input();
1408        status.actual_transport = ResolutionTransport::UserConfiguredRecursiveHnsDoh;
1409        status.identities = TransportIdentities::default();
1410        status.registry_fingerprint = [0; 32];
1411        status.protocol_version = 0;
1412
1413        let status = BrowserStatus::new(status).unwrap();
1414
1415        assert_eq!(
1416            status.actual_transport(),
1417            ResolutionTransport::UserConfiguredRecursiveHnsDoh
1418        );
1419        assert_eq!(status.identities(), &TransportIdentities::default());
1420    }
1421
1422    #[test]
1423    fn local_hns_proof_is_non_network_status_provenance() {
1424        let mut status = input();
1425        status.actual_transport = ResolutionTransport::LocalHnsProof;
1426        status.identities = TransportIdentities::default();
1427        status.registry_fingerprint = [0; 32];
1428        status.protocol_version = 0;
1429
1430        let status = BrowserStatus::new(status).unwrap();
1431
1432        assert_eq!(
1433            status.actual_transport(),
1434            ResolutionTransport::LocalHnsProof
1435        );
1436        assert_eq!(status.identities(), &TransportIdentities::default());
1437    }
1438
1439    #[test]
1440    fn explicit_unattempted_stale_unsupported_and_revoked_states_survive() {
1441        let mut status = input();
1442        let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([12; 16]).unwrap());
1443        runtime.transition(AuthorityState::Degraded).unwrap();
1444        status.runtime = runtime.snapshot();
1445        status.actual_transport = ResolutionTransport::Unavailable;
1446        status.identities = TransportIdentities::default();
1447        status.registry_fingerprint = [0; 32];
1448        status.protocol_version = 0;
1449        status.chain_anchor = None;
1450        status.evidence = ValidationEvidence::not_attempted();
1451        status.evidence.hns_proof = EvidenceState::Stale;
1452        status.evidence.dnssec = EvidenceState::Unsupported;
1453        status.evidence.tlsa = EvidenceState::Unavailable;
1454        status.evidence.dane = EvidenceState::Revoked;
1455        status.evidence.origin_sni = EvidenceState::Failed;
1456        status.unsupported_evidence.push(UnsupportedEvidence {
1457            kind: EvidenceKind::Dnssec,
1458            code: 253,
1459        });
1460        status.degraded_reason = Some(DegradedReason::HeadersStale);
1461        let status = BrowserStatus::new(status).unwrap();
1462        assert_eq!(status.evidence().hns_proof, EvidenceState::Stale);
1463        assert_eq!(status.evidence().dnssec, EvidenceState::Unsupported);
1464        assert_eq!(status.evidence().dane, EvidenceState::Revoked);
1465        assert_eq!(status.unsupported_evidence().len(), 1);
1466    }
1467
1468    #[test]
1469    fn provider_readiness_is_policy_derived_and_disabled_roles_stay_disabled() {
1470        let mut config = policy().config();
1471        config.providers = ProviderPolicy {
1472            dns_relay: false,
1473            odoh_proxy: false,
1474            odoh_target: false,
1475            market_gossip: false,
1476        };
1477        config.hnsr = HnsrPolicy::disabled();
1478        let disabled_policy = PolicySnapshot::new(8, config).unwrap();
1479        let readiness = ProviderReadiness::from_policy(disabled_policy);
1480        assert_eq!(readiness, ProviderReadiness::default());
1481
1482        let mut status = input();
1483        status.policy = disabled_policy;
1484        status.provider_readiness = readiness;
1485        status.actual_transport = ResolutionTransport::Unavailable;
1486        status.identities = TransportIdentities::default();
1487        status.registry_fingerprint = [0; 32];
1488        status.protocol_version = 0;
1489        status.chain_anchor = None;
1490        status.evidence = ValidationEvidence::not_attempted();
1491        BrowserStatus::new(status.clone()).unwrap();
1492
1493        status.provider_readiness.odoh_proxy = ReadinessState::Ready;
1494        assert_eq!(
1495            BrowserStatus::new(status),
1496            Err(StatusError::InvalidProviderReadiness)
1497        );
1498    }
1499
1500    #[test]
1501    fn provider_and_rate_limit_invariants_reject_misreporting() {
1502        let mut status = input();
1503        status.provider_readiness.odoh_proxy = ReadinessState::Ready;
1504        assert_eq!(
1505            BrowserStatus::new(status),
1506            Err(StatusError::InvalidProviderReadiness)
1507        );
1508
1509        let mut status = input();
1510        status.rate_limits.in_flight = status.rate_limits.max_concurrency;
1511        assert_eq!(
1512            BrowserStatus::new(status),
1513            Err(StatusError::InvalidRateLimit)
1514        );
1515    }
1516
1517    #[test]
1518    fn authority_state_enforces_failure_reason_consistency() {
1519        let mut runtime = BrowserRuntime::new(RuntimeSessionId::new([9; 16]).unwrap());
1520        runtime.transition(AuthorityState::Degraded).unwrap();
1521        let mut status = input();
1522        status.runtime = runtime.snapshot();
1523        status.chain_anchor = None;
1524        status.actual_transport = ResolutionTransport::Unavailable;
1525        status.identities = TransportIdentities::default();
1526        status.registry_fingerprint = [0; 32];
1527        status.protocol_version = 0;
1528        status.evidence = ValidationEvidence::not_attempted();
1529        assert_eq!(
1530            BrowserStatus::new(status.clone()),
1531            Err(StatusError::MissingFailureReason)
1532        );
1533        status.degraded_reason = Some(DegradedReason::HeaderSyncUnavailable);
1534        BrowserStatus::new(status.clone()).unwrap();
1535
1536        status.revocation_reason = Some(RevocationReason::RuntimeChanged);
1537        assert_eq!(
1538            BrowserStatus::new(status),
1539            Err(StatusError::ConflictingFailureReasons)
1540        );
1541
1542        let mut stopped = BrowserRuntime::new(RuntimeSessionId::new([10; 16]).unwrap());
1543        stopped.transition(AuthorityState::Stopped).unwrap();
1544        let mut status = input();
1545        status.runtime = stopped.snapshot();
1546        status.chain_anchor = None;
1547        status.actual_transport = ResolutionTransport::Unavailable;
1548        status.identities = TransportIdentities::default();
1549        status.registry_fingerprint = [0; 32];
1550        status.protocol_version = 0;
1551        status.evidence = ValidationEvidence::revoked();
1552        status.revocation_reason = Some(RevocationReason::PolicyChanged);
1553        assert_eq!(
1554            BrowserStatus::new(status.clone()),
1555            Err(StatusError::FailureReasonMismatch)
1556        );
1557        status.revocation_reason = Some(RevocationReason::Stopped);
1558        BrowserStatus::new(status).unwrap();
1559    }
1560
1561    #[test]
1562    fn failure_reason_matrix_is_exhaustive_for_every_authority_state() {
1563        let states = [
1564            AuthorityState::Uninitialized,
1565            AuthorityState::LocalStateOpened,
1566            AuthorityState::HeaderSyncing,
1567            AuthorityState::HeaderCurrent,
1568            AuthorityState::ProofReady,
1569            AuthorityState::ResolutionTransportReady,
1570            AuthorityState::DnssecVerified,
1571            AuthorityState::DaneOriginVerified,
1572            AuthorityState::BrowserBridgeReady,
1573            AuthorityState::Active,
1574            AuthorityState::Degraded,
1575            AuthorityState::Revoked,
1576            AuthorityState::Stopped,
1577        ];
1578        let degraded_options = [None, Some(DegradedReason::ResolutionTransportUnavailable)];
1579        let revocation_options = [
1580            None,
1581            Some(RevocationReason::PolicyChanged),
1582            Some(RevocationReason::Stopped),
1583        ];
1584
1585        for authority in states {
1586            for degraded in degraded_options {
1587                for revoked in revocation_options {
1588                    let expected = match authority {
1589                        AuthorityState::Degraded => degraded.is_some() && revoked.is_none(),
1590                        AuthorityState::Revoked => {
1591                            degraded.is_none()
1592                                && revoked.is_some()
1593                                && revoked != Some(RevocationReason::Stopped)
1594                        }
1595                        AuthorityState::Stopped => {
1596                            degraded.is_none() && revoked == Some(RevocationReason::Stopped)
1597                        }
1598                        _ => degraded.is_none() && revoked.is_none(),
1599                    };
1600                    assert_eq!(
1601                        validate_failure_reasons(authority, degraded, revoked).is_ok(),
1602                        expected,
1603                        "unexpected reason result for {authority:?}, {degraded:?}, {revoked:?}"
1604                    );
1605                }
1606            }
1607        }
1608    }
1609
1610    fn icann_input(action: IcannTlsAction) -> StatusInput {
1611        let mut status = input();
1612        status.runtime = active_runtime(11, action == IcannTlsAction::EnforceDane);
1613        status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1614        status.identities = TransportIdentities::default();
1615        status.registry_fingerprint = [0; 32];
1616        status.protocol_version = 0;
1617        status.chain_anchor = None;
1618        status.namespace_outcome = Some(OutcomeKind::IcannOnly);
1619        status.selected_namespace = Some(Namespace::Icann);
1620        status.selection_reason = Some(SelectionReason::SingleRoot);
1621        status.decision_fingerprint = Some([11; 32]);
1622        status.icann_tls_action = Some(action);
1623        status.icann_dnssec_status = Some(if action == IcannTlsAction::WebPkiInsecureDelegation {
1624            IcannDnssecStatus::InsecureDelegation
1625        } else {
1626            IcannDnssecStatus::Secure
1627        });
1628        status.evidence = ValidationEvidence::not_attempted();
1629        status
1630    }
1631
1632    fn failed_icann_input(
1633        failure: RootFailureKind,
1634        dnssec_status: Option<IcannDnssecStatus>,
1635        evidence: ValidationEvidence,
1636    ) -> StatusInput {
1637        let mut status = input();
1638        status.runtime = active_runtime(11, false);
1639        status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1640        status.identities = TransportIdentities::default();
1641        status.registry_fingerprint = [0; 32];
1642        status.protocol_version = 0;
1643        status.chain_anchor = None;
1644        status.namespace_outcome = None;
1645        status.hns_root_failure = None;
1646        status.icann_root_failure = Some(failure);
1647        status.selected_namespace = None;
1648        status.selection_reason = None;
1649        status.decision_fingerprint = None;
1650        status.icann_tls_action = Some(IcannTlsAction::FailClosed);
1651        status.icann_dnssec_status = dnssec_status;
1652        status.evidence = evidence;
1653        status
1654    }
1655
1656    #[test]
1657    fn reports_icann_dane_without_names_or_registry_metadata() {
1658        let mut status = icann_input(IcannTlsAction::EnforceDane);
1659        status.evidence.dnssec = EvidenceState::Verified;
1660        status.evidence.tlsa = EvidenceState::Verified;
1661        status.evidence.dane = EvidenceState::Verified;
1662        let status = BrowserStatus::new(status).unwrap();
1663        assert_eq!(
1664            status.actual_transport(),
1665            ResolutionTransport::ValidatingIcannDoh
1666        );
1667        assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::EnforceDane));
1668        assert_eq!(status.selected_namespace(), Some(Namespace::Icann));
1669        assert_eq!(status.decision_fingerprint(), Some([11; 32]));
1670    }
1671
1672    #[test]
1673    fn webpki_authenticated_absence_becomes_active_without_claiming_dane() {
1674        let mut status = icann_input(IcannTlsAction::WebPkiAuthenticatedAbsence);
1675        status.evidence.dnssec = EvidenceState::Verified;
1676        status.evidence.tlsa = EvidenceState::Unavailable;
1677        status.evidence.dane = EvidenceState::NotAttempted;
1678        let status = BrowserStatus::new(status).unwrap();
1679        assert_eq!(status.authority_state(), AuthorityState::Active);
1680        assert_eq!(status.evidence().dane, EvidenceState::NotAttempted);
1681        assert_eq!(
1682            status.icann_tls_action(),
1683            Some(IcannTlsAction::WebPkiAuthenticatedAbsence)
1684        );
1685    }
1686
1687    #[test]
1688    fn bogus_icann_evidence_is_explicitly_fail_closed() {
1689        let mut evidence = ValidationEvidence::not_attempted();
1690        evidence.dnssec = EvidenceState::Failed;
1691        let mut status = failed_icann_input(
1692            RootFailureKind::BogusDnssec,
1693            Some(IcannDnssecStatus::Bogus),
1694            evidence,
1695        );
1696        status.icann_tls_action = None;
1697        assert_eq!(
1698            BrowserStatus::new(status.clone()),
1699            Err(StatusError::InvalidIcannTlsContext)
1700        );
1701        status.icann_tls_action = Some(IcannTlsAction::FailClosed);
1702        status.actual_transport = ResolutionTransport::Unavailable;
1703        assert_eq!(
1704            BrowserStatus::new(status.clone()),
1705            Err(StatusError::InvalidIcannTlsContext)
1706        );
1707        status.actual_transport = ResolutionTransport::ValidatingIcannDoh;
1708        let status = BrowserStatus::new(status).unwrap();
1709        assert_eq!(status.namespace_outcome(), None);
1710        assert_eq!(status.selected_namespace(), None);
1711        assert_eq!(
1712            status.icann_root_failure(),
1713            Some(RootFailureKind::BogusDnssec)
1714        );
1715        assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1716        assert_ne!(status.evidence().dnssec, EvidenceState::Unavailable);
1717    }
1718
1719    #[test]
1720    fn indeterminate_icann_dnssec_remains_explicitly_fail_closed() {
1721        let mut evidence = ValidationEvidence::not_attempted();
1722        evidence.dnssec = EvidenceState::Unavailable;
1723        evidence.tlsa = EvidenceState::Unavailable;
1724        evidence.dane = EvidenceState::Unavailable;
1725        let status = failed_icann_input(
1726            RootFailureKind::IndeterminateDnssec,
1727            Some(IcannDnssecStatus::Indeterminate),
1728            evidence,
1729        );
1730        let status = BrowserStatus::new(status).unwrap();
1731        assert_eq!(status.evidence().dnssec, EvidenceState::Unavailable);
1732        assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1733    }
1734
1735    #[test]
1736    fn hns_only_root_failure_clears_transport_provenance() {
1737        let mut status = input();
1738        status.chain_anchor = None;
1739        status.identities = TransportIdentities::default();
1740        status.registry_fingerprint = [0; 32];
1741        status.protocol_version = 0;
1742        status.evidence = ValidationEvidence::not_attempted();
1743        status.hns_root_failure = Some(RootFailureKind::StaleHnsAnchor);
1744        status.actual_transport = ResolutionTransport::DirectAuthoritativeTcp;
1745        assert_eq!(
1746            BrowserStatus::new(status.clone()),
1747            Err(StatusError::InvalidNamespaceContext)
1748        );
1749        status.actual_transport = ResolutionTransport::Unavailable;
1750        let status = BrowserStatus::new(status).unwrap();
1751        assert_eq!(status.actual_transport(), ResolutionTransport::Unavailable);
1752    }
1753
1754    #[test]
1755    fn post_selection_dane_failure_retains_the_namespace_outcome() {
1756        let mut status = icann_input(IcannTlsAction::FailClosed);
1757        status.evidence.dnssec = EvidenceState::Verified;
1758        status.evidence.tlsa = EvidenceState::Verified;
1759        status.evidence.dane = EvidenceState::Failed;
1760        let status = BrowserStatus::new(status).unwrap();
1761        assert_eq!(status.namespace_outcome(), Some(OutcomeKind::IcannOnly));
1762        assert_eq!(status.selected_namespace(), Some(Namespace::Icann));
1763        assert_eq!(status.icann_root_failure(), None);
1764        assert_eq!(
1765            status.icann_dnssec_status(),
1766            Some(IcannDnssecStatus::Secure)
1767        );
1768    }
1769
1770    #[test]
1771    fn stale_revoked_and_not_attempted_icann_evidence_can_fail_closed() {
1772        for (failure, evidence) in [
1773            (
1774                RootFailureKind::StaleEvidence,
1775                ValidationEvidence {
1776                    dnssec: EvidenceState::Stale,
1777                    tlsa: EvidenceState::Unavailable,
1778                    dane: EvidenceState::Unavailable,
1779                    ..ValidationEvidence::not_attempted()
1780                },
1781            ),
1782            (
1783                RootFailureKind::Cancelled,
1784                ValidationEvidence {
1785                    dnssec: EvidenceState::Unavailable,
1786                    tlsa: EvidenceState::Revoked,
1787                    dane: EvidenceState::Unavailable,
1788                    ..ValidationEvidence::not_attempted()
1789                },
1790            ),
1791            (
1792                RootFailureKind::Cancelled,
1793                ValidationEvidence::not_attempted(),
1794            ),
1795        ] {
1796            let status = failed_icann_input(failure, None, evidence);
1797            let status = BrowserStatus::new(status).unwrap();
1798            assert_eq!(status.icann_tls_action(), Some(IcannTlsAction::FailClosed));
1799        }
1800    }
1801
1802    #[test]
1803    fn icann_tls_actions_cannot_reinterpret_failure_or_fallback_evidence() {
1804        let mut authenticated_absence = icann_input(IcannTlsAction::WebPkiAuthenticatedAbsence);
1805        authenticated_absence.evidence.dnssec = EvidenceState::Verified;
1806        authenticated_absence.evidence.tlsa = EvidenceState::Unavailable;
1807        authenticated_absence.evidence.dane = EvidenceState::NotAttempted;
1808        BrowserStatus::new(authenticated_absence.clone()).unwrap();
1809
1810        let mut indeterminate = authenticated_absence.clone();
1811        indeterminate.evidence.dnssec = EvidenceState::Unavailable;
1812        indeterminate.evidence.dane = EvidenceState::Unavailable;
1813        assert_eq!(
1814            BrowserStatus::new(indeterminate.clone()),
1815            Err(StatusError::InvalidIcannTlsContext)
1816        );
1817        indeterminate.icann_tls_action = Some(IcannTlsAction::FailClosed);
1818        assert_eq!(
1819            BrowserStatus::new(indeterminate),
1820            Err(StatusError::InvalidIcannTlsContext)
1821        );
1822
1823        let mut failure_as_fallback = authenticated_absence.clone();
1824        failure_as_fallback.evidence.dnssec = EvidenceState::Failed;
1825        assert_eq!(
1826            BrowserStatus::new(failure_as_fallback),
1827            Err(StatusError::InvalidIcannTlsContext)
1828        );
1829
1830        let mut fallback_as_failure = authenticated_absence.clone();
1831        fallback_as_failure.icann_tls_action = Some(IcannTlsAction::FailClosed);
1832        assert_eq!(
1833            BrowserStatus::new(fallback_as_failure),
1834            Err(StatusError::InvalidIcannTlsContext)
1835        );
1836
1837        let mut absence_as_insecure = authenticated_absence;
1838        absence_as_insecure.icann_tls_action = Some(IcannTlsAction::WebPkiInsecureDelegation);
1839        assert_eq!(
1840            BrowserStatus::new(absence_as_insecure),
1841            Err(StatusError::InvalidIcannTlsContext)
1842        );
1843
1844        let mut dane = icann_input(IcannTlsAction::EnforceDane);
1845        dane.evidence.dnssec = EvidenceState::Verified;
1846        dane.evidence.tlsa = EvidenceState::Verified;
1847        dane.evidence.dane = EvidenceState::Verified;
1848        BrowserStatus::new(dane.clone()).unwrap();
1849        let mut dane_as_failure = dane.clone();
1850        dane_as_failure.icann_tls_action = Some(IcannTlsAction::FailClosed);
1851        assert_eq!(
1852            BrowserStatus::new(dane_as_failure),
1853            Err(StatusError::InvalidIcannTlsContext)
1854        );
1855        dane.evidence.dane = EvidenceState::Unavailable;
1856        assert_eq!(
1857            BrowserStatus::new(dane),
1858            Err(StatusError::InvalidIcannTlsContext)
1859        );
1860
1861        let mut insecure = icann_input(IcannTlsAction::WebPkiInsecureDelegation);
1862        insecure.evidence.dnssec = EvidenceState::Verified;
1863        insecure.evidence.tlsa = EvidenceState::Unavailable;
1864        insecure.evidence.dane = EvidenceState::Unavailable;
1865        BrowserStatus::new(insecure.clone()).unwrap();
1866        insecure.icann_tls_action = Some(IcannTlsAction::WebPkiAuthenticatedAbsence);
1867        assert_eq!(
1868            BrowserStatus::new(insecure),
1869            Err(StatusError::InvalidIcannTlsContext)
1870        );
1871    }
1872
1873    #[test]
1874    fn reports_divergent_root_selection_without_hostname_data() {
1875        let mut status = input();
1876        status.namespace_outcome = Some(OutcomeKind::BothDivergent);
1877        status.selected_namespace = Some(Namespace::Hns);
1878        status.selection_reason = Some(SelectionReason::ExplicitPin);
1879        status.decision_fingerprint = Some([12; 32]);
1880        status.icann_tls_action = None;
1881        let status = BrowserStatus::new(status).unwrap();
1882        assert_eq!(status.namespace_outcome(), Some(OutcomeKind::BothDivergent));
1883        assert_eq!(status.selected_namespace(), Some(Namespace::Hns));
1884        assert_eq!(
1885            status.selection_reason(),
1886            Some(SelectionReason::ExplicitPin)
1887        );
1888    }
1889
1890    #[test]
1891    fn selected_icann_cleartext_may_omit_tls_action() {
1892        let mut status = icann_input(IcannTlsAction::FailClosed);
1893        status.icann_tls_action = None;
1894        status.evidence = ValidationEvidence::not_attempted();
1895        status.evidence.dnssec = EvidenceState::Verified;
1896        BrowserStatus::new(status).unwrap();
1897    }
1898
1899    #[test]
1900    fn selected_icann_cleartext_still_requires_validated_dnssec() {
1901        for dnssec in [
1902            EvidenceState::Failed,
1903            EvidenceState::Unavailable,
1904            EvidenceState::Unsupported,
1905            EvidenceState::NotAttempted,
1906            EvidenceState::Stale,
1907            EvidenceState::Revoked,
1908        ] {
1909            let mut status = icann_input(IcannTlsAction::FailClosed);
1910            status.icann_tls_action = None;
1911            status.evidence = ValidationEvidence::not_attempted();
1912            status.evidence.dnssec = dnssec;
1913            assert_eq!(
1914                BrowserStatus::new(status),
1915                Err(StatusError::InvalidIcannTlsContext)
1916            );
1917        }
1918    }
1919
1920    #[test]
1921    fn namespace_selection_reason_matrix_matches_the_classifier() {
1922        let outcomes = [
1923            OutcomeKind::HnsOnly,
1924            OutcomeKind::IcannOnly,
1925            OutcomeKind::BothConvergent,
1926            OutcomeKind::BothDivergent,
1927            OutcomeKind::Neither,
1928        ];
1929        let selections = [None, Some(Namespace::Hns), Some(Namespace::Icann)];
1930        let reasons = [
1931            None,
1932            Some(SelectionReason::SingleRoot),
1933            Some(SelectionReason::ExplicitPin),
1934            Some(SelectionReason::StickyBinding),
1935            Some(SelectionReason::IcannDefault),
1936        ];
1937
1938        for outcome in outcomes {
1939            for selected in selections {
1940                for reason in reasons {
1941                    let expected = matches!(
1942                        (outcome, selected, reason),
1943                        (OutcomeKind::Neither, None, None)
1944                            | (
1945                                OutcomeKind::HnsOnly,
1946                                Some(Namespace::Hns),
1947                                Some(
1948                                    SelectionReason::SingleRoot
1949                                        | SelectionReason::ExplicitPin
1950                                        | SelectionReason::StickyBinding,
1951                                ),
1952                            )
1953                            | (
1954                                OutcomeKind::IcannOnly,
1955                                Some(Namespace::Icann),
1956                                Some(
1957                                    SelectionReason::SingleRoot
1958                                        | SelectionReason::ExplicitPin
1959                                        | SelectionReason::StickyBinding,
1960                                ),
1961                            )
1962                            | (
1963                                OutcomeKind::BothConvergent | OutcomeKind::BothDivergent,
1964                                Some(Namespace::Hns),
1965                                Some(SelectionReason::ExplicitPin | SelectionReason::StickyBinding),
1966                            )
1967                            | (
1968                                OutcomeKind::BothConvergent | OutcomeKind::BothDivergent,
1969                                Some(Namespace::Icann),
1970                                Some(
1971                                    SelectionReason::ExplicitPin
1972                                        | SelectionReason::StickyBinding
1973                                        | SelectionReason::IcannDefault,
1974                                ),
1975                            )
1976                    );
1977                    assert_eq!(
1978                        valid_namespace_selection(Some(outcome), selected, reason),
1979                        expected,
1980                        "unexpected selection matrix result for {outcome:?}, {selected:?}, {reason:?}"
1981                    );
1982                }
1983            }
1984        }
1985    }
1986
1987    #[test]
1988    fn namespace_decision_fields_are_structurally_bound() {
1989        let mut status = input();
1990        status.namespace_outcome = Some(OutcomeKind::IcannOnly);
1991        status.selected_namespace = Some(Namespace::Hns);
1992        status.selection_reason = Some(SelectionReason::SingleRoot);
1993        status.decision_fingerprint = Some([13; 32]);
1994        assert_eq!(
1995            BrowserStatus::new(status),
1996            Err(StatusError::InvalidNamespaceContext)
1997        );
1998
1999        let mut status = input();
2000        status.namespace_outcome = Some(OutcomeKind::Neither);
2001        status.decision_fingerprint = Some([0; 32]);
2002        assert_eq!(
2003            BrowserStatus::new(status),
2004            Err(StatusError::InvalidDecisionFingerprint)
2005        );
2006
2007        let mut status = input();
2008        status.namespace_outcome = Some(OutcomeKind::Neither);
2009        status.selected_namespace = None;
2010        status.selection_reason = None;
2011        status.decision_fingerprint = Some([15; 32]);
2012        assert_eq!(
2013            BrowserStatus::new(status),
2014            Err(StatusError::InvalidNamespaceContext)
2015        );
2016
2017        let mut status = input();
2018        status.namespace_outcome = Some(OutcomeKind::BothDivergent);
2019        status.selected_namespace = Some(Namespace::Hns);
2020        status.selection_reason = Some(SelectionReason::ExplicitPin);
2021        status.decision_fingerprint = Some([14; 32]);
2022        status.icann_tls_action = Some(IcannTlsAction::FailClosed);
2023        assert_eq!(
2024            BrowserStatus::new(status),
2025            Err(StatusError::InvalidIcannTlsContext)
2026        );
2027    }
2028
2029    #[test]
2030    fn effective_runtime_feature_state_preserves_wiring_layers() {
2031        let active = RuntimeFeatureState::active(Some(true));
2032        assert!(active.is_compiled());
2033        assert!(active.is_configured());
2034        assert!(active.is_active());
2035        assert_eq!(active.observed(), Some(true));
2036
2037        let disabled = RuntimeFeatureState::compiled_disabled();
2038        assert!(disabled.is_compiled());
2039        assert!(!disabled.is_configured());
2040        assert!(!disabled.is_active());
2041        assert_eq!(disabled.observed(), None);
2042
2043        let inactive = RuntimeFeatureState::configured_inactive();
2044        assert!(inactive.is_compiled());
2045        assert!(inactive.is_configured());
2046        assert!(!inactive.is_active());
2047    }
2048
2049    #[test]
2050    fn effective_runtime_feature_state_rejects_impossible_claims() {
2051        assert_eq!(
2052            RuntimeFeatureState::try_new(false, true, false, None),
2053            Err(RuntimeFeatureStateError::ConfiguredWithoutCapability),
2054        );
2055        assert_eq!(
2056            RuntimeFeatureState::try_new(true, false, true, None),
2057            Err(RuntimeFeatureStateError::ActiveWithoutConfiguration),
2058        );
2059        assert_eq!(
2060            RuntimeFeatureState::try_new(true, true, false, Some(true)),
2061            Err(RuntimeFeatureStateError::ObservedWithoutActivePath),
2062        );
2063    }
2064
2065    #[test]
2066    fn name_tree_authority_follows_hsd_commit_boundaries() {
2067        for network in [Network::Mainnet, Network::Testnet] {
2068            assert_eq!(name_tree_interval(network), 36);
2069            assert_eq!(name_tree_authority_height(network, 0), 0);
2070            assert_eq!(name_tree_authority_height(network, 1), 1);
2071            assert_eq!(name_tree_authority_height(network, 36), 1);
2072            assert_eq!(name_tree_authority_height(network, 37), 37);
2073            assert_eq!(name_tree_authority_height(network, 72), 37);
2074            assert_eq!(name_tree_authority_height(network, 73), 73);
2075        }
2076
2077        assert_eq!(name_tree_interval(Network::Regtest), 5);
2078        assert_eq!(name_tree_authority_height(Network::Regtest, 5), 1);
2079        assert_eq!(name_tree_authority_height(Network::Regtest, 6), 6);
2080        assert_eq!(name_tree_interval(Network::Simnet), 2);
2081        assert_eq!(name_tree_authority_height(Network::Simnet, 2), 1);
2082        assert_eq!(name_tree_authority_height(Network::Simnet, 3), 3);
2083    }
2084
2085    #[test]
2086    fn name_tree_currentness_waits_only_for_a_new_authority_epoch() {
2087        let same_epoch = NameTreeCurrentness::assess(Network::Mainnet, Some(1), Some(36));
2088        assert!(same_epoch.is_ready());
2089        assert_eq!(same_epoch.local_authority_height(), Some(1));
2090        assert_eq!(same_epoch.target_authority_height(), Some(1));
2091        assert_eq!(same_epoch.blocks_until_authority(), Some(0));
2092
2093        let boundary = NameTreeCurrentness::assess(Network::Mainnet, Some(36), Some(37));
2094        assert!(!boundary.is_ready());
2095        assert_eq!(boundary.target_authority_height(), Some(37));
2096        assert_eq!(boundary.blocks_until_authority(), Some(1));
2097
2098        let caught_up = NameTreeCurrentness::assess(Network::Mainnet, Some(37), Some(72));
2099        assert!(caught_up.is_ready());
2100        assert_eq!(caught_up.local_header_height(), Some(37));
2101        assert_eq!(caught_up.target_header_height(), Some(72));
2102
2103        assert!(!NameTreeCurrentness::assess(Network::Mainnet, Some(72), None).is_ready());
2104        assert!(!NameTreeCurrentness::assess(Network::Mainnet, Some(0), Some(1)).is_ready());
2105    }
2106}