nautalid 0.1.0

Scratch container substrate — TLS 1.3 HTTP/2+3 kernel, LID/AetherDB, optional filter bus (GPL-3.0-or-later).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Crate embedding — programmatic backend configuration (not env-only).
//!
//! Binary entrypoints use [`EmbedConfig::from_env`]; library consumers build
//! [`EmbedConfig`] (or [`EmbedBuilder`]) and call [`install_subsystems`] after
//! assembling [`crate::state::AppState`].

use std::sync::Arc;

use crate::state::AppState;

#[cfg(feature = "kwt")]
use crate::kwt_replay::AetherRuntime;
#[cfg(feature = "kwt")]
use crate::wt_aether::WtAetherConfig;

/// Programmatic subsystem toggles for Nautalid-as-a-library.
#[derive(Debug, Clone)]
pub struct EmbedConfig {
    /// Enable HTTP/3 WebTransport session handling (also settable via `NAUTALID_WEBTRANSPORT=1`).
    pub webtransport: bool,
    /// WebTransport ↔ AetherDB bridge policy (`None` = off unless env enables aether).
    #[cfg(feature = "kwt")]
    pub wt_aether: Option<WtAetherConfig>,
}

impl Default for EmbedConfig {
    fn default() -> Self {
        Self {
            webtransport: false,
            #[cfg(feature = "kwt")]
            wt_aether: None,
        }
    }
}

impl EmbedConfig {
    /// Mirror binary/container env for WebTransport and WT ↔ Aether routing.
    #[must_use]
    pub fn from_env() -> Self {
        let webtransport = crate::webtransport::enabled_from_env();
        #[cfg(feature = "kwt")]
        let wt_aether = if webtransport || crate::surfaces::env_enabled("NAUTALID_WEBTRANSPORT_AETHER")
        {
            Some(WtAetherConfig::from_env())
        } else {
            None
        };
        Self {
            webtransport,
            #[cfg(feature = "kwt")]
            wt_aether,
        }
    }
}

/// Fluent builder for [`EmbedConfig`].
#[derive(Debug, Default)]
pub struct EmbedBuilder {
    config: EmbedConfig,
}

impl EmbedBuilder {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn from_env() -> Self {
        Self {
            config: EmbedConfig::from_env(),
        }
    }

    #[must_use]
    pub fn webtransport(mut self, enabled: bool) -> Self {
        self.config.webtransport = enabled;
        self
    }

    #[cfg(feature = "kwt")]
    #[must_use]
    pub fn wt_aether(mut self, config: WtAetherConfig) -> Self {
        self.config.wt_aether = Some(config);
        self
    }

    #[must_use]
    pub fn build(self) -> EmbedConfig {
        self.config
    }
}

/// Wire optional backends after manual [`AppState`] assembly.
pub fn install_subsystems(state: &AppState, config: &EmbedConfig) {
    crate::webtransport::set_enabled(config.webtransport);

    #[cfg(feature = "kwt")]
    if let Some(runtime) = &state.aether_runtime {
        if let Some(wt) = &config.wt_aether {
            #[cfg(feature = "filter")]
            crate::wt_aether::install_with_filter(
                Arc::clone(runtime),
                wt.clone(),
                Some(state.filter.clone()),
            );
            #[cfg(not(feature = "filter"))]
            crate::wt_aether::install(Arc::clone(runtime), wt.clone());
        } else if config.webtransport {
            #[cfg(feature = "filter")]
            crate::wt_aether::install_with_filter(
                Arc::clone(runtime),
                WtAetherConfig::from_env(),
                Some(state.filter.clone()),
            );
            #[cfg(not(feature = "filter"))]
            crate::wt_aether::install(
                Arc::clone(runtime),
                WtAetherConfig::from_env(),
            );
        }
        runtime.ensure_wire_pool();
    }

    let _ = state;
}

/// Env-driven install (binary default).
pub fn install_subsystems_from_env(state: &AppState) {
    install_subsystems(state, &EmbedConfig::from_env());
}

#[cfg(feature = "kwt")]
/// Assemble a minimal LID-enabled [`AppState`] for crate embedding.
pub fn state_with_runtime(
    runtime: Arc<AetherRuntime>,
    kwt: crate::kwt_access::KwtAccessConfig,
) -> AppState {
    AppState::new(
        #[cfg(feature = "image-trust")]
        None,
        Some(kwt),
        Some(runtime),
        #[cfg(feature = "filter")]
        crate::filter::FilterStore::default(),
    )
}