Skip to main content

shivya_telemetry/
lib.rs

1use wasm_bindgen::prelude::*;
2use shivya_hodge::complex::SimplicialStateComplex;
3
4/// Physics-derived strain proxy used when no live telemetry is supplied.
5///
6/// In a browser the host's CPU is sandboxed away, so we fall back to a
7/// deterministic Gierer–Meinhardt-coupled signal: strain rises with the local
8/// activator `u` and is damped by the inhibitor `v`. Native (rlib) builds use
9/// the exact same formula so unit tests remain reproducible.
10#[cfg(target_arch = "wasm32")]
11fn derived_strain(step: usize, node: usize, u: f64, v: f64) -> Vec<f64> {
12    // Bounded, deterministic, monotone in u and inverse in v.
13    let phase = (step as f64) * 0.05 + (node as f64) * 0.3;
14    let activator_strain = (u / (1.0 + v.abs())).clamp(0.0, 1.0);
15    let drift = 0.5 + 0.25 * phase.sin();
16    let primary = 0.4 * activator_strain + 0.6 * drift;
17    vec![primary.clamp(0.0, 1.0), (primary * 0.85).clamp(0.0, 1.0)]
18}
19
20#[cfg(not(target_arch = "wasm32"))]
21fn derived_strain(step: usize, node: usize, u: f64, v: f64) -> Vec<f64> {
22    let phase = (step as f64) * 0.05 + (node as f64) * 0.3;
23    let activator_strain = (u / (1.0 + v.abs())).clamp(0.0, 1.0);
24    let drift = 0.5 + 0.25 * phase.sin();
25    let primary = 0.4 * activator_strain + 0.6 * drift;
26    vec![primary.clamp(0.0, 1.0), (primary * 0.85).clamp(0.0, 1.0)]
27}
28use shivya_hodge::reconciler::reconcile_state_delta;
29use shivya_flux::model::GibbsFluxAgent;
30use shivya_morphic::{DynamicGibbsAgent, Expr, MorphicHotSwapper, compile};
31use shivya_onsager::OnsagerCollectiveEnsemble;
32use shivya_turing::{MorphogenSystem, MitosisEngine, ApoptosisEngine};
33
34// Keeps ShivyaSimulation backward-compatible for safety
35#[wasm_bindgen]
36pub struct ShivyaSimulation {
37    complex: SimplicialStateComplex,
38    agent: GibbsFluxAgent<2, 1, 2>,
39}
40
41#[wasm_bindgen]
42impl ShivyaSimulation {
43    #[wasm_bindgen(constructor)]
44    pub fn new() -> Self {
45        let mut complex = SimplicialStateComplex::new();
46        complex.add_vertex("A", 10.0);
47        complex.add_vertex("B", 10.0);
48        complex.add_vertex("C", 10.0);
49        complex.add_edge("A", "B", 1.0);
50        complex.add_edge("B", "C", 1.0);
51        complex.add_edge("A", "C", 1.5);
52
53        let agent = GibbsFluxAgent::new(
54            [0.0, 0.0],
55            [[10.0, 0.0], [0.0, 10.0]],
56            [[2.0, 0.5], [0.5, 1.5]],
57            [[0.1, 0.0], [0.0, 0.1]],
58            [[1.0], [0.5]],
59            [[1.0], [0.5]],
60            [0.0, 0.0],
61            [[1.0, 0.0], [0.0, 1.0]],
62        );
63
64        Self { complex, agent }
65    }
66
67    pub fn add_vertex(&mut self, label: &str, initial_state: f64) -> usize {
68        self.complex.add_vertex(label, initial_state)
69    }
70
71    pub fn add_edge(&mut self, u_label: &str, v_label: &str, initial_state: f64) {
72        self.complex.add_edge(u_label, v_label, initial_state);
73    }
74
75    pub fn get_vertices_count(&self) -> usize {
76        self.complex.vertices.len()
77    }
78
79    pub fn get_edges_count(&self) -> usize {
80        self.complex.edges.len()
81    }
82
83    pub fn get_triangles_count(&self) -> usize {
84        self.complex.triangles.len()
85    }
86
87    pub fn get_vertex_label(&self, idx: usize) -> String {
88        self.complex.vertices.get(idx).cloned().unwrap_or_default()
89    }
90
91    pub fn get_vertex_state(&self, idx: usize) -> f64 {
92        self.complex.vertex_states.get(idx).cloned().unwrap_or(0.0)
93    }
94
95    pub fn get_edge_u(&self, idx: usize) -> usize {
96        self.complex.edges.get(idx).map(|&(u, _)| u).unwrap_or(0)
97    }
98
99    pub fn get_edge_v(&self, idx: usize) -> usize {
100        self.complex.edges.get(idx).map(|&(_, v)| v).unwrap_or(0)
101    }
102
103    pub fn get_edge_state(&self, idx: usize) -> f64 {
104        self.complex.edge_states.get(idx).cloned().unwrap_or(0.0)
105    }
106
107    pub fn reconcile_flows(&self, delta_s: Vec<f64>) -> Vec<f64> {
108        reconcile_state_delta(&self.complex, &delta_s)
109    }
110
111    pub fn agent_update_beliefs(&mut self, obs_0: f64, obs_1: f64) -> Vec<f64> {
112        self.agent.update_beliefs(&[obs_0, obs_1], 0.1, 100, 1e-6)
113    }
114
115    pub fn agent_free_energy(&self, obs_0: f64, obs_1: f64) -> f64 {
116        self.agent.compute_free_energy(&[obs_0, obs_1], &self.agent.mu_q, &self.agent.sigma_q)
117    }
118
119    pub fn get_agent_beliefs(&self) -> Vec<f64> {
120        self.agent.mu_q.to_vec()
121    }
122}
123
124// Full 5-Layer browser WebAssembly orchestrator
125#[wasm_bindgen]
126pub struct SubstrateOrchestrator {
127    max_nodes: usize,
128    complex: SimplicialStateComplex,
129    ensemble: OnsagerCollectiveEnsemble,
130    swappers: Vec<MorphicHotSwapper>,
131    turing: MorphogenSystem,
132    mitosis: MitosisEngine,
133    apoptosis: ApoptosisEngine,
134    step_count: usize,
135}
136
137#[wasm_bindgen]
138impl SubstrateOrchestrator {
139    #[wasm_bindgen(constructor)]
140    pub fn new() -> Self {
141        let max_nodes = 10;
142        let mut complex = SimplicialStateComplex::new();
143        // Setup initial simplicial mesh
144        complex.add_vertex("Node0", 1.0);
145        complex.add_vertex("Node1", 1.2);
146        complex.add_vertex("Node2", 0.9);
147        complex.add_edge("Node0", "Node1", 0.5);
148        complex.add_edge("Node1", "Node2", 0.6);
149        complex.add_edge("Node0", "Node2", 0.8);
150
151        let adjacent_nodes = vec![
152            vec![1, 2],
153            vec![0, 2],
154            vec![0, 1],
155            vec![], // Slot 3 dormant
156            vec![], // Slot 4 dormant
157            vec![], // Slot 5 dormant
158            vec![], // Slot 6 dormant
159            vec![], // Slot 7 dormant
160            vec![], // Slot 8 dormant
161            vec![], // Slot 9 dormant
162        ];
163
164        let create_agent = |mu_prior_val: f64| {
165            DynamicGibbsAgent::new(
166                2, 1, 2,
167                vec![mu_prior_val, 0.0],
168                vec![vec![10.0, 0.0], vec![0.0, 10.0]],
169                vec![vec![1.5, 0.2], vec![0.2, 1.2]],
170                vec![vec![0.1, 0.0], vec![0.0, 0.1]],
171                vec![vec![0.0], vec![0.0]],
172                vec![vec![0.0], vec![0.0]],
173                vec![0.0, 0.0],
174                vec![vec![1.0, 0.0], vec![0.0, 1.0]],
175                5.0,
176            )
177        };
178
179        let mut agents = Vec::new();
180        for i in 0..max_nodes {
181            agents.push(create_agent(0.1 + (i as f64) * 0.05));
182        }
183
184        let base_coupling = 0.5;
185        let ensemble = OnsagerCollectiveEnsemble::new(agents, adjacent_nodes, base_coupling);
186
187        let create_swapper = || {
188            MorphicHotSwapper::new(Expr::Mul(
189                Box::new(Expr::Const(1.0)),
190                Box::new(Expr::Var(0)),
191            ))
192        };
193        let mut swappers = Vec::new();
194        for _ in 0..max_nodes {
195            swappers.push(create_swapper());
196        }
197
198        let mut turing = MorphogenSystem::new(max_nodes, 0.01, 0.1);
199        turing.activate_node(0, 0.5, 1.0);
200        turing.activate_node(1, 0.2, 1.0);
201        turing.activate_node(2, 0.3, 1.0);
202        turing.set_edge(0, 1, 1.0);
203        turing.set_edge(1, 2, 1.0);
204        turing.set_edge(0, 2, 1.0);
205
206        let mitosis = MitosisEngine::new(2.0, 0.01);
207        let apoptosis = ApoptosisEngine::new(0.05);
208
209        Self {
210            max_nodes,
211            complex,
212            ensemble,
213            swappers,
214            turing,
215            mitosis,
216            apoptosis,
217            step_count: 0,
218        }
219    }
220
221    pub fn reset(&mut self) {
222        let mut complex = SimplicialStateComplex::new();
223        complex.add_vertex("Node0", 1.0);
224        complex.add_vertex("Node1", 1.2);
225        complex.add_vertex("Node2", 0.9);
226        complex.add_edge("Node0", "Node1", 0.5);
227        complex.add_edge("Node1", "Node2", 0.6);
228        complex.add_edge("Node0", "Node2", 0.8);
229
230        let adjacent_nodes = vec![
231            vec![1, 2],
232            vec![0, 2],
233            vec![0, 1],
234            vec![], vec![], vec![], vec![], vec![], vec![], vec![],
235        ];
236
237        let create_agent = |mu_prior_val: f64| {
238            DynamicGibbsAgent::new(
239                2, 1, 2,
240                vec![mu_prior_val, 0.0],
241                vec![vec![10.0, 0.0], vec![0.0, 10.0]],
242                vec![vec![1.5, 0.2], vec![0.2, 1.2]],
243                vec![vec![0.1, 0.0], vec![0.0, 0.1]],
244                vec![vec![0.0], vec![0.0]],
245                vec![vec![0.0], vec![0.0]],
246                vec![0.0, 0.0],
247                vec![vec![1.0, 0.0], vec![0.0, 1.0]],
248                5.0,
249            )
250        };
251
252        let mut agents = Vec::new();
253        for i in 0..self.max_nodes {
254            agents.push(create_agent(0.1 + (i as f64) * 0.05));
255        }
256
257        let ensemble = OnsagerCollectiveEnsemble::new(agents, adjacent_nodes, 0.5);
258
259        let create_swapper = || {
260            MorphicHotSwapper::new(Expr::Mul(
261                Box::new(Expr::Const(1.0)),
262                Box::new(Expr::Var(0)),
263            ))
264        };
265        let mut swappers = Vec::new();
266        for _ in 0..self.max_nodes {
267            swappers.push(create_swapper());
268        }
269
270        let mut turing = MorphogenSystem::new(self.max_nodes, 0.01, 0.1);
271        turing.activate_node(0, 0.5, 1.0);
272        turing.activate_node(1, 0.2, 1.0);
273        turing.activate_node(2, 0.3, 1.0);
274        turing.set_edge(0, 1, 1.0);
275        turing.set_edge(1, 2, 1.0);
276        turing.set_edge(0, 2, 1.0);
277
278        self.complex = complex;
279        self.ensemble = ensemble;
280        self.swappers = swappers;
281        self.turing = turing;
282        self.step_count = 0;
283    }
284
285    pub fn inject_stress(&mut self, node_id: usize) -> bool {
286        if node_id < self.max_nodes && self.turing.active[node_id] {
287            // Force morphogen u high above mitosis threshold (2.0)
288            self.turing.u[node_id] = 2.5;
289            true
290        } else {
291            false
292        }
293    }
294
295    pub fn trigger_apoptosis(&mut self, node_id: usize) -> bool {
296        if node_id < self.max_nodes && self.turing.active[node_id] {
297            // Force morphogen u very low (0.01) and spike the agent's free energy in history
298            self.turing.u[node_id] = 0.01;
299            self.turing.v[node_id] = 2.0;
300            self.ensemble.agents[node_id].f_history.push(8.5); // Spike free energy
301            true
302        } else {
303            false
304        }
305    }
306
307    pub fn step(&mut self, inputs: &[f64]) -> String {
308        self.step_count += 1;
309
310        // 1. Gather active indices
311        let mut active_indices = Vec::new();
312        for i in 0..self.max_nodes {
313            if self.turing.active[i] {
314                active_indices.push(i);
315            }
316        }
317
318        // 2. Scale coupling coefficients based on network parameters
319        let base_coupling = 0.5;
320        for i in 0..self.max_nodes {
321            for j in 0..self.max_nodes {
322                if i != j {
323                    self.ensemble.regulator.l_matrix[i][j] = base_coupling;
324                }
325            }
326        }
327
328        // CPU observations come from one of two sources:
329        //   - real `inputs` (callers wired to actual JS-side telemetry), or
330        //   - a deterministic physics-derived strain model when no inputs are
331        //     supplied. The browser sandbox forbids reading host CPU, so a
332        //     reproducible diffusion-driven proxy stands in.
333        let mut obs = vec![vec![0.0, 0.0]; self.max_nodes];
334        for &i in &active_indices {
335            if 2 * i + 1 < inputs.len() {
336                obs[i][0] = inputs[2 * i];
337                obs[i][1] = inputs[2 * i + 1];
338            } else {
339                obs[i] = derived_strain(self.step_count, i, self.turing.u[i], self.turing.v[i]);
340            }
341        }
342
343        // Step Onsager Collective Ensemble (Layer 3 & 1)
344        let collective_f = self.ensemble.step(&obs, 0.1, 10, 1e-4, 0.1);
345
346        // 4. Morphic Hot-swapping VM updates (Layer 2)
347        for &i in &active_indices {
348            let dataset = vec![
349                (vec![obs[i][0]], obs[i][0] * 1.5),
350                (vec![obs[i][1]], obs[i][1] * 1.5),
351            ];
352            let seed = (self.step_count + i * 99) as u32;
353            self.swappers[i].run_metamorphic_step(&dataset, seed);
354        }
355
356        // 5. Reconcile topological states (Layer 0)
357        let mut delta_s = vec![0.0; self.complex.edges.len()];
358        // Fill delta_s with small perturbations from observations
359        for i in 0..delta_s.len() {
360            let u_idx = self.complex.edges[i].0;
361            let val = if u_idx < obs.len() { obs[u_idx][0] } else { 0.5 };
362            delta_s[i] = val * 0.15;
363        }
364        let reconciled = reconcile_state_delta(&self.complex, &delta_s);
365        let curl_deviation: f64 = reconciled.iter().zip(delta_s.iter())
366            .map(|(&r, &d)| (r - d).powi(2))
367            .sum::<f64>().sqrt();
368
369        // 6. Gierer-Meinhardt reaction diffusion step (Layer 4)
370        self.turing.step_rk4(0.05);
371
372        // Gather beliefs & adjacency for Mitosis/Apoptosis
373        let mut beliefs: Vec<Vec<f64>> = self.ensemble.agents.iter().map(|a| a.mu_q.clone()).collect();
374        let mut adjacent_nodes = self.ensemble.adjacent_nodes.clone();
375
376        // 7. Mitosis Engine split evaluation
377        let mut hotswap_status = vec![false; self.max_nodes];
378        if let Some((parent, child)) = self.mitosis.evaluate_and_split(&mut self.turing, &mut beliefs, &mut adjacent_nodes) {
379            // Apply new beliefs to child agent
380            self.ensemble.agents[child].mu_q = beliefs[child].clone();
381            self.ensemble.agents[child].i_dim = beliefs[child].len();
382            // Sync adjacency list
383            self.ensemble.adjacent_nodes = adjacent_nodes.clone();
384            // Update Hodge Mesh topology
385            let child_label = format!("Node{}", child);
386            self.complex.add_vertex(&child_label, 1.0);
387            let parent_label = format!("Node{}", parent);
388            let _ = self.complex.add_edge(&parent_label, &child_label, 1.0);
389            hotswap_status[child] = true; // Mark as newly hotswapped/split
390        }
391
392        // 8. Apoptosis Engine pruning evaluation
393        let mut free_energies = vec![0.0; self.max_nodes];
394        for i in 0..self.max_nodes {
395            free_energies[i] = self.ensemble.agents[i].f_history.last().cloned().unwrap_or(0.0);
396        }
397        if let Some(_pruned_node) = self.apoptosis.evaluate_and_prune(&mut self.turing, &mut beliefs, &mut adjacent_nodes, &free_energies, 5.0) {
398            // Sync changes back
399            self.ensemble.adjacent_nodes = adjacent_nodes;
400        }
401
402        // 9. Re-collect updated active indices
403        let mut updated_active = Vec::new();
404        for i in 0..self.max_nodes {
405            if self.turing.active[i] {
406                updated_active.push(i);
407            }
408        }
409
410        // 10. Compile equations and build status JSON
411        let mut equations = vec![String::new(); self.max_nodes];
412        let mut inst_counts = vec![0; self.max_nodes];
413        for i in 0..self.max_nodes {
414            let expr = &self.swappers[i].current_expr;
415            equations[i] = format!("{:?}", expr);
416            let (insts, _) = compile(expr);
417            inst_counts[i] = insts.len();
418        }
419
420        let mut edges = Vec::new();
421        for &u in &updated_active {
422            if u < self.ensemble.adjacent_nodes.len() {
423                for &v in &self.ensemble.adjacent_nodes[u] {
424                    if u < v && updated_active.contains(&v) {
425                        edges.push((u, v));
426                    }
427                }
428            }
429        }
430
431        let mut json = String::new();
432        json.push_str("{\n");
433        json.push_str(&format!("  \"collective_free_energy\": {:.6},\n", collective_f));
434        json.push_str(&format!("  \"curl_deviation\": {:.6},\n", curl_deviation));
435        json.push_str(&format!("  \"step_count\": {},\n", self.step_count));
436        json.push_str(&format!("  \"active_nodes_count\": {},\n", updated_active.len()));
437        
438        json.push_str("  \"active_pool\": [");
439        let active_pool_str = updated_active.iter().map(|idx| idx.to_string()).collect::<Vec<String>>().join(", ");
440        json.push_str(&active_pool_str);
441        json.push_str("],\n");
442
443        json.push_str("  \"edges\": [");
444        let edges_str = edges.iter().map(|&(u, v)| format!("[{}, {}]", u, v)).collect::<Vec<String>>().join(", ");
445        json.push_str(&edges_str);
446        json.push_str("],\n");
447
448        json.push_str("  \"nodes\": [\n");
449        for (i, &idx) in updated_active.iter().enumerate() {
450            let agent = &self.ensemble.agents[idx];
451            let beliefs_str = agent.mu_q.iter()
452                .map(|val| format!("{:.6}", val))
453                .collect::<Vec<String>>()
454                .join(", ");
455
456            json.push_str("    {\n");
457            json.push_str(&format!("      \"id\": {},\n", idx));
458            json.push_str(&format!("      \"active\": true,\n"));
459            json.push_str(&format!("      \"free_energy\": {:.6},\n", agent.f_history.last().cloned().unwrap_or(0.0)));
460            json.push_str(&format!("      \"belief_dim\": {},\n", agent.i_dim));
461            json.push_str(&format!("      \"beliefs\": [{}],\n", beliefs_str));
462            json.push_str(&format!("      \"morphic_equation\": \"{}\",\n", equations[idx].replace("\"", "\\\"")));
463            json.push_str(&format!("      \"instruction_count\": {},\n", inst_counts[idx]));
464            json.push_str(&format!("      \"morphogen_u\": {:.6},\n", self.turing.u[idx]));
465            json.push_str(&format!("      \"morphogen_v\": {:.6},\n", self.turing.v[idx]));
466            json.push_str(&format!("      \"hotswapped\": {}\n", hotswap_status[idx]));
467
468            if i < updated_active.len() - 1 {
469                json.push_str("    },\n");
470            } else {
471                json.push_str("    }\n");
472            }
473        }
474        json.push_str("  ]\n");
475        json.push_str("}");
476
477        json
478    }
479}