active-infinity 1.1.2

Active Infinity (Active ∞) — binary, zero-copy, content-addressable, graph-native, unit-aware and secret-safe data language for Active modules and AI agents
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

//! End-to-end tour: text → Infinity → validate → view → decode → stream.
//!
//! ```bash
//! cargo run --example roundtrip
//! ```
//!
//! The output is deterministic; the run-twice launch check in the release
//! procedure compares two invocations byte for byte.

use active_infinity::stream::{self, StreamDecoder};
use active_infinity::{
    content_hash, decode, encode, validate, InfinityModule, InfinityView, Limits,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let module = build()?;
    let bytes = encode(&module)?;
    let meta = validate(&bytes)?;
    println!(
        "module:      {} nodes, {} bytes",
        meta.nodes, meta.total_size
    );
    println!(
        "content:     blake3:{}",
        active_infinity::ir::hash_hex(&meta.content_hash)
    );

    let view = InfinityView::new(&bytes, Limits::default())?;
    println!(
        "view:        {} nodes, hash agrees: {}",
        view.node_count(),
        view.content_hash() == meta.content_hash
    );

    let decoded = decode(&bytes)?;
    let reencoded = encode(&decoded)?;
    println!("round-trip:  equal values: {}", decoded == module);
    println!("round-trip:  identical bytes: {}", reencoded == bytes);

    // Streaming: one generation, reassembled chunk by chunk.
    let frames = stream::encode_stream(&module, 32)?;
    let mut wire = Vec::new();
    for frame in &frames {
        wire.extend_from_slice(&frame.to_bytes());
    }
    let mut decoder = StreamDecoder::new();
    for piece in wire.chunks(7) {
        decoder.push_bytes(piece)?;
    }
    let streamed = decoder.finish()?;
    println!(
        "stream:      {} frames, identical image: {}, identical hash: {}",
        frames.len(),
        streamed.image == bytes,
        streamed.content_hash == content_hash(&bytes)?
    );

    // Redacted projection: secret material never appears.
    #[cfg(feature = "json")]
    {
        let json = active_infinity::interop::to_redacted_json(&decoded)?;
        println!("projection:  {} bytes of redacted JSON", json.len());
        println!("projection:  contains secret: {}", json.contains("hunter2"));
    }
    Ok(())
}

fn build() -> Result<InfinityModule, Box<dyn std::error::Error>> {
    #[cfg(feature = "active-core")]
    {
        let source = r#"
# @intent: "Round-trip fixture"
[app]
name  = "roundtrip"
port  = 8080
ratio = 25%
label = "v1"
"#;
        Ok(active_infinity::interop::from_active_source(
            source,
            "roundtrip.active",
        )?)
    }
    #[cfg(not(feature = "active-core"))]
    {
        use active_infinity::Inode;
        let mut module = InfinityModule::new();
        let text = module.push(Inode::Str("roundtrip".into()));
        let port = module.push(Inode::Int(8080));
        let root = module.push(Inode::Table {
            fields: vec![("name".into(), text), ("port".into(), port)],
        });
        module.set_root(Some(root));
        Ok(module)
    }
}