1use wasm_bindgen::prelude::*;
2use shivya_hodge::complex::SimplicialStateComplex;
3
4#[cfg(target_arch = "wasm32")]
11fn derived_strain(step: usize, node: usize, u: f64, v: f64) -> Vec<f64> {
12 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#[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#[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 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![], vec![], vec![], vec![], vec![], vec![], vec![], ];
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 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 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); true
302 } else {
303 false
304 }
305 }
306
307 pub fn step(&mut self, inputs: &[f64]) -> String {
308 self.step_count += 1;
309
310 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 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 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 let collective_f = self.ensemble.step(&obs, 0.1, 10, 1e-4, 0.1);
345
346 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 let mut delta_s = vec![0.0; self.complex.edges.len()];
358 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 self.turing.step_rk4(0.05);
371
372 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 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 self.ensemble.agents[child].mu_q = beliefs[child].clone();
381 self.ensemble.agents[child].i_dim = beliefs[child].len();
382 self.ensemble.adjacent_nodes = adjacent_nodes.clone();
384 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; }
391
392 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 self.ensemble.adjacent_nodes = adjacent_nodes;
400 }
401
402 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 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}