lsp-max 26.7.3

Law-state LSP runtime: max LSP 3.18 coverage, process-mining conformance, receipt-chain admission
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

//! Runtime utilities for lsp-max servers.
//!
//! Provides SHA-256 hashing, the `ConformanceVector` (Admitted/Refused/Unknown
//! tallies), and the `MaxServer` wrapper that wires a `LanguageServer` impl into
//! the five-layer AMI execution model used by lsp-max.

pub mod ledger;
pub mod mesh;
pub mod mesh_hooks;
pub mod mesh_types;
pub mod rpc;
pub mod sha256;
pub mod typestate;

pub use mesh::{build_conformance_vector, AutonomicMesh, MaxMesh};
pub use mesh_hooks::{
    CustomerRequestClassifierHook, IntakeClearHook, IntakeDiagnosticHook, OcelProcessHook,
    PolicyEvaluationHook, ReceiptRoutingHook,
};
pub use mesh_types::{
    AutonomicMeshState, ConformanceDeltaEntry, ConformanceGrade, FailureMode, Hook, HookDescriptor,
    HookEvent, InstanceId, LspInstance, LspPhase, MaxDiagnostic, MaxMethod, MeshAction,
    PolicyState, Receipt,
};
pub use sha256::{sha256, validate_and_reconstruct_chain_checked};
pub use typestate::{
    AccessAdmissionLaw, ChainError, Data, DeterministicSnapshot, EmptyData, Exited, Initialized,
    InitializedData, Initializing, InitializingData, Law, Machine, Phase, ShutDown,
    TypestateKernel, Uninitialized,
};

pub mod control_plane;
pub use control_plane::replay;
pub use control_plane::views;

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

    #[test]
    fn all_hooks_have_non_empty_descriptors() {
        let mut mesh = AutonomicMesh::new();
        mesh.register_hook(Box::new(mesh_hooks::IntakeDiagnosticHook));
        mesh.register_hook(Box::new(mesh_hooks::IntakeClearHook));
        mesh.register_hook(Box::new(mesh_hooks::CustomerRequestClassifierHook::new()));
        mesh.register_hook(Box::new(mesh_hooks::PolicyEvaluationHook::new()));
        mesh.register_hook(Box::new(mesh_hooks::ReceiptRoutingHook::new()));
        mesh.register_hook(Box::new(mesh_hooks::OcelProcessHook::new()));

        let descriptors = mesh.hook_descriptors();
        assert_eq!(descriptors.len(), 6, "expected exactly 6 registered hooks");

        for d in &descriptors {
            assert!(!d.name.is_empty(), "hook name must not be empty");
            assert!(
                !d.input_type.is_empty(),
                "input_type must not be empty for {}",
                d.name
            );
            assert!(
                !d.output_type.is_empty(),
                "output_type must not be empty for {}",
                d.name
            );
            assert!(
                !d.trigger_law.is_empty(),
                "trigger_law must not be empty for {}",
                d.name
            );
        }
    }

    #[test]
    fn hook_names_match_struct_names() {
        let hooks: Vec<Box<dyn mesh_types::Hook>> = vec![
            Box::new(mesh_hooks::IntakeDiagnosticHook),
            Box::new(mesh_hooks::IntakeClearHook),
            Box::new(mesh_hooks::CustomerRequestClassifierHook::new()),
            Box::new(mesh_hooks::PolicyEvaluationHook::new()),
            Box::new(mesh_hooks::ReceiptRoutingHook::new()),
            Box::new(mesh_hooks::OcelProcessHook::new()),
        ];
        let expected_names = [
            "IntakeDiagnosticHook",
            "IntakeClearHook",
            "CustomerRequestClassifierHook",
            "PolicyEvaluationHook",
            "ReceiptRoutingHook",
            "OcelProcessHook",
        ];
        for (hook, expected) in hooks.iter().zip(expected_names.iter()) {
            assert_eq!(hook.name(), *expected);
            assert_eq!(hook.descriptor().name, *expected);
        }
    }
}