noether-core 0.4.0

Noether core: type system, effects, content-addressed stage schema, Ed25519 signing, stdlib
Documentation 
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

mod collections;
mod control;
mod data;
mod internal;
mod io;
mod kv;
mod llm;
mod process;
mod scalar;
mod text;
mod ui;
mod validation;

use crate::stage::Stage;
use ed25519_dalek::SigningKey;
use sha2::{Digest, Sha256};

/// Deterministic Ed25519 keypair for stdlib signing.
/// Derived from SHA-256 of a fixed seed string.
pub fn stdlib_signing_key() -> SigningKey {
    let seed = Sha256::digest(b"noether-stdlib-signing-key-v0.1.0");
    SigningKey::from_bytes(&seed.into())
}

/// Load all stdlib stages, signed and ready for store insertion.
pub fn load_stdlib() -> Vec<Stage> {
    let key = stdlib_signing_key();
    let mut stages = Vec::new();
    stages.extend(scalar::stages(&key));
    stages.extend(collections::stages(&key));
    stages.extend(control::stages(&key));
    stages.extend(io::stages(&key));
    stages.extend(llm::stages(&key));
    stages.extend(data::stages(&key));
    stages.extend(internal::stages(&key));
    stages.extend(text::stages(&key));
    stages.extend(kv::stages(&key));
    stages.extend(validation::stages(&key));
    stages.extend(ui::stages(&key));
    stages.extend(process::stages(&key));
    stages
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn load_stdlib_returns_50_stages() {
        let stages = load_stdlib();
        assert_eq!(stages.len(), 80); // 76 existing + 4 process stages
    }

    #[test]
    fn stdlib_ids_are_deterministic() {
        let stages1 = load_stdlib();
        let stages2 = load_stdlib();
        for (s1, s2) in stages1.iter().zip(stages2.iter()) {
            assert_eq!(s1.id, s2.id, "Stage IDs should be deterministic");
        }
    }

    #[test]
    fn all_stdlib_stages_are_active() {
        let stages = load_stdlib();
        for s in &stages {
            assert_eq!(
                s.lifecycle,
                crate::stage::StageLifecycle::Active,
                "Stdlib stage '{}' should be Active",
                s.description
            );
        }
    }

    #[test]
    fn all_stdlib_stages_are_signed() {
        let stages = load_stdlib();
        for s in &stages {
            assert!(
                s.ed25519_signature.is_some(),
                "Stdlib stage '{}' should be signed",
                s.description
            );
        }
    }

    #[test]
    fn no_duplicate_ids() {
        let stages = load_stdlib();
        let mut ids: Vec<_> = stages.iter().map(|s| &s.id).collect();
        let len_before = ids.len();
        ids.sort();
        ids.dedup();
        assert_eq!(ids.len(), len_before, "All stage IDs should be unique");
    }
}