zebflow 0.7.0

Reactive web automation platform — pipelines, templates, and real-time collaboration in a single binary.
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
98
99
100

//! Zebflow core crate.
//!
//! This crate is intentionally split into independent subsystems:
//!
//! 1. [`pipeline`] for pipeline orchestration (graph traversal, node dispatch)
//! 2. [`language`] for sandboxed script execution (Deno)
//! 3. [`rwe`] for reactive web template compile/render (TSX → SSR → hydrate)
//! 4. [`automaton`] for autonomous objective planning/execution + LLM clients (Zebtune)
//! 5. [`platform`] for service composition and web shell (Axum, MCP, DSL)
//! 6. [`infra`] for shared runtime infrastructure (WebSocket, storage, scheduler)
//!
//! The [`ZebflowEngineKit`] type wires default implementations so an app entrypoint
//! can keep `main.rs` thin and delegate all behavior to library modules.

pub mod automaton;
pub mod infra;
pub mod language;
pub mod mapserver;
pub mod pipeline;
pub mod platform;
pub mod provision;
pub mod rwe;
pub mod version;
pub mod zebfs;

use std::sync::Arc;

use automaton::{AutomatonEngine, AutomatonEngineRegistry, NoopAutomatonEngine};
use language::{DenoSandboxEngine, LanguageEngine, LanguageEngineRegistry, NoopLanguageEngine};
use pipeline::{BasicPipelineEngine, NoopPipelineEngine, PipelineEngine, PipelineEngineRegistry};
use rwe::{ReactiveWebEngine, ReactiveWebEngineRegistry, RweReactiveWebEngine};

/// Ready-to-use set of engine registries for pipeline/language/rwe modules.
///
/// This is the main composition root used by hosts (CLI, server, tests) to
/// lookup engine implementations by id.
#[derive(Clone)]
pub struct ZebflowEngineKit {
    /// Automaton engines.
    pub automaton: AutomatonEngineRegistry,
    /// Pipeline execution engines.
    pub pipeline: PipelineEngineRegistry,
    /// Script/runtime engines.
    pub language: LanguageEngineRegistry,
    /// Reactive web engines.
    pub rwe: ReactiveWebEngineRegistry,
}

impl ZebflowEngineKit {
    /// Builds a kit with default engines registered:
    ///
    /// - `pipeline.basic`
    /// - `pipeline.noop`
    /// - `language.deno_sandbox`
    /// - `language.noop`
    /// - `rwe`
    /// - `automaton.noop`
    pub fn with_defaults() -> Self {
        let mut automaton = AutomatonEngineRegistry::new();
        automaton.register(Arc::new(NoopAutomatonEngine));

        let mut pipeline = PipelineEngineRegistry::new();
        pipeline.register(Arc::new(BasicPipelineEngine::default()));
        pipeline.register(Arc::new(NoopPipelineEngine::default()));

        let mut language = LanguageEngineRegistry::new();
        language.register(Arc::new(DenoSandboxEngine::default()));
        language.register(Arc::new(NoopLanguageEngine::default()));

        let mut rwe = ReactiveWebEngineRegistry::new();
        rwe.register(Arc::new(RweReactiveWebEngine::default()));

        Self {
            automaton,
            pipeline,
            language,
            rwe,
        }
    }

    /// Returns an automaton engine by id.
    pub fn automaton_engine(&self, id: &str) -> Option<Arc<dyn AutomatonEngine>> {
        self.automaton.get(id)
    }

    /// Returns a pipeline execution engine by id.
    pub fn pipeline_engine(&self, id: &str) -> Option<Arc<dyn PipelineEngine>> {
        self.pipeline.get(id)
    }

    /// Returns a language engine by id.
    pub fn language_engine(&self, id: &str) -> Option<Arc<dyn LanguageEngine>> {
        self.language.get(id)
    }

    /// Returns an RWE engine by id.
    pub fn rwe_engine(&self, id: &str) -> Option<Arc<dyn ReactiveWebEngine>> {
        self.rwe.get(id)
    }
}