1use serde::{Deserialize, Serialize};
14
15use wellfare_core::anatomy::{
16 self, body_system_for_organ, burden_to_sigma, overlay_host_systems, system_representation,
17 AnatomyView, Hypothesis, KnowledgeBase, Lens, PhysiologicalState, Provenance, RecordRef,
18 ScoreCard, SystemBurden, SystemRepresentation, WellbeingLevel,
19};
20
21use qualia_core_db::render::{acoustic, spectral};
22
23use super::journal::JournalEntry;
24
25const BUNDLED_CONDITION_MAP: &str =
27 include_str!("../../../../bundled/qapps/Anatomy/Knowledge/condition-map.json");
28
29const DISCLOSURE: &str = "Conditions map via the bundled condition→system reference. Food, herb, and medication mappings currently use an illustrative seed set pending a curated knowledge corpus — treat those as examples, not authoritative. This is a general picture to explore with a clinician, not a diagnosis.";
30
31#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
33pub struct UnmappedRecord {
34 pub kind: String,
35 pub label: String,
36}
37
38#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
40pub struct AnatomyViewReport {
41 pub view: AnatomyView,
43 pub burdens: Vec<SystemBurden>,
45 pub unmapped: Vec<UnmappedRecord>,
47 pub mapped_count: usize,
49 pub total_records: usize,
51 pub disclosure: String,
53}
54
55#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
61pub struct SystemPercept {
62 pub system_id: String,
63 pub level: WellbeingLevel,
65 pub sigma: f32,
67 pub rgba: [f32; 4],
69 pub frequency_hz: f32,
71}
72
73#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
77pub struct OrganPercept {
78 pub organ_key: String,
80 pub system_id: String,
82 pub percept: SystemPercept,
84}
85
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
90pub struct OverlayPercept {
91 pub system_id: String,
92 pub percept: SystemPercept,
94 pub host_systems: Vec<String>,
96}
97
98impl AnatomyViewReport {
99 pub fn system_percepts(&self) -> Vec<SystemPercept> {
104 self.burdens
105 .iter()
106 .map(|b| system_percept(&b.system_id, b.net_milli))
107 .collect()
108 }
109
110 pub fn paint_organs(&self, organ_keys: &[&str]) -> (Vec<OrganPercept>, Vec<String>) {
117 let percepts = self.system_percepts();
118 let mut painted = Vec::new();
119 let mut unmapped = Vec::new();
120 for &organ in organ_keys {
121 match body_system_for_organ(organ) {
122 Some(system_id) => {
123 let percept = percepts
124 .iter()
125 .find(|p| p.system_id == system_id)
126 .cloned()
127 .unwrap_or_else(|| system_percept(system_id, 0));
128 painted.push(OrganPercept {
129 organ_key: organ.to_string(),
130 system_id: system_id.to_string(),
131 percept,
132 });
133 }
134 None => unmapped.push(organ.to_string()),
135 }
136 }
137 (painted, unmapped)
138 }
139
140 pub fn overlay_percepts(&self) -> Vec<OverlayPercept> {
146 overlay_percepts_from_burdens(&self.burdens)
147 }
148}
149
150fn overlay_percepts_from_burdens(burdens: &[SystemBurden]) -> Vec<OverlayPercept> {
153 burdens
154 .iter()
155 .filter(|b| system_representation(&b.system_id) == SystemRepresentation::DistributedOverlay)
156 .map(|b| OverlayPercept {
157 host_systems: overlay_host_systems(&b.system_id)
158 .iter()
159 .map(|s| s.to_string())
160 .collect(),
161 percept: system_percept(&b.system_id, b.net_milli),
162 system_id: b.system_id.clone(),
163 })
164 .collect()
165}
166
167fn system_percept(system_id: &str, net_milli: u32) -> SystemPercept {
169 let sigma = burden_to_sigma(net_milli);
170 SystemPercept {
171 system_id: system_id.to_string(),
172 level: WellbeingLevel::from_net(net_milli),
173 sigma,
174 rgba: sigma_to_normalized_linear_rgba(sigma),
175 frequency_hz: acoustic::sigma_to_center_frequency_hz(sigma),
176 }
177}
178
179fn sigma_to_normalized_linear_rgba(sigma: f32) -> [f32; 4] {
184 let lin = spectral::sigma_to_linear_rgb(sigma);
185 let scale = 1.0 / lin.iter().copied().fold(0.0_f32, f32::max).max(1e-6);
186 [
187 (lin[0] * scale).clamp(0.0, 1.0),
188 (lin[1] * scale).clamp(0.0, 1.0),
189 (lin[2] * scale).clamp(0.0, 1.0),
190 1.0,
191 ]
192}
193
194pub fn parse_lens(s: &str) -> Lens {
196 match s.trim().to_ascii_lowercase().as_str() {
197 "clinician" => Lens::Clinician,
198 _ => Lens::Person,
199 }
200}
201
202pub fn host_knowledge_base() -> KnowledgeBase {
204 let mut kb = anatomy::seed_knowledge_base();
205 let prov = Provenance {
206 source_id: "clinical-reference".to_string(),
207 source_title: "Bundled condition→system reference map".to_string(),
208 citation: None,
209 imported_at: None,
210 };
211 if let Ok(res) =
215 anatomy::import_condition_map(BUNDLED_CONDITION_MAP, prov, anatomy::default_registry())
216 {
217 for entry in res.entries {
218 kb.insert(entry);
219 }
220 }
221 kb
222}
223
224pub fn record_refs_from_journal(
227 conditions: &[JournalEntry],
228 medications: &[JournalEntry],
229 diet: &[JournalEntry],
230) -> Vec<RecordRef> {
231 let mut refs = Vec::new();
232 for e in conditions {
233 if let Some(label) = summary_str(e, "label") {
234 refs.push(RecordRef::new(e.id.clone(), "condition", label));
235 }
236 }
237 for e in medications {
238 if summary_bool(e, "ceased") == Some(true) {
239 continue;
240 }
241 if let Some(name) = summary_str(e, "name") {
242 refs.push(RecordRef::new(e.id.clone(), "medication", name));
243 }
244 }
245 for e in diet {
246 if let Some(desc) = summary_str(e, "description") {
247 refs.push(RecordRef::new(e.id.clone(), "diet", desc));
248 }
249 }
250 refs
251}
252
253pub fn build_report(
257 records: Vec<RecordRef>,
258 lens: Lens,
259 convergence_threshold: usize,
260 state: PhysiologicalState,
261) -> AnatomyViewReport {
262 let total_records = records.len();
263 let kb = host_knowledge_base();
264 let bridge = anatomy::records_to_factors(&records, &kb);
265 let raw_burdens = anatomy::accumulate(&bridge.factors);
266 let burdens = anatomy::state_modulator(state).apply_to_burdens(&raw_burdens);
267 let view = anatomy::build_view(&bridge.factors, lens, convergence_threshold);
268 AnatomyViewReport {
269 view,
270 burdens,
271 unmapped: bridge
272 .unmapped
273 .into_iter()
274 .map(|(kind, label)| UnmappedRecord { kind, label })
275 .collect(),
276 mapped_count: bridge.factors.len(),
277 total_records,
278 disclosure: DISCLOSURE.to_string(),
279 }
280}
281
282pub fn build_report_from_journal(
284 conditions: &[JournalEntry],
285 medications: &[JournalEntry],
286 diet: &[JournalEntry],
287 lens: Lens,
288 convergence_threshold: usize,
289 state: PhysiologicalState,
290) -> AnatomyViewReport {
291 let refs = record_refs_from_journal(conditions, medications, diet);
292 build_report(refs, lens, convergence_threshold, state)
293}
294
295const SCORECARD_DISCLOSURE: &str = "This score-card is your own inward reading (forum-internum, Sanctuary-class) — a set of Hypotheses to explore, not a diagnosis and not a rating. Each aspect links to the underlying considerations, and each is a starting point toward knowing more (questions to ask, what could be tracked or tested, levers you control, when a clinician you choose could help).";
298
299#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
303pub struct WellbeingScorecardReport {
304 pub scorecard: ScoreCard,
306 pub hypotheses: Vec<Hypothesis>,
309 pub forum_internum: bool,
311 pub sensitivity_class: String,
313 pub mapped_count: usize,
315 pub total_records: usize,
316 pub disclosure: String,
317}
318
319pub fn build_scorecard_report_with_weights(
323 records: Vec<RecordRef>,
324 convergence_threshold: usize,
325 weight_model: &anatomy::WeightModel,
326 state: PhysiologicalState,
327) -> WellbeingScorecardReport {
328 let total_records = records.len();
329 let kb = host_knowledge_base();
330 let bridge = anatomy::records_to_factors(&records, &kb);
331 let scorecard =
332 anatomy::score_card(&bridge.factors, convergence_threshold, state, weight_model);
333 let implications = anatomy::systemic_implications(&bridge.factors, convergence_threshold);
334 let hypotheses = anatomy::hypotheses_from_implications(&implications);
335 WellbeingScorecardReport {
336 forum_internum: scorecard.forum_class() == anatomy::ForumClass::Internum,
337 sensitivity_class: scorecard.sensitivity_class().to_string(),
338 scorecard,
339 hypotheses,
340 mapped_count: bridge.factors.len(),
341 total_records,
342 disclosure: SCORECARD_DISCLOSURE.to_string(),
343 }
344}
345
346pub fn build_scorecard_report(
350 records: Vec<RecordRef>,
351 convergence_threshold: usize,
352 state: PhysiologicalState,
353) -> WellbeingScorecardReport {
354 build_scorecard_report_with_weights(
355 records,
356 convergence_threshold,
357 &anatomy::seed_weight_model(),
358 state,
359 )
360}
361
362pub fn build_scorecard_report_from_journal_with_weights(
364 conditions: &[JournalEntry],
365 medications: &[JournalEntry],
366 diet: &[JournalEntry],
367 convergence_threshold: usize,
368 weight_model: &anatomy::WeightModel,
369 state: PhysiologicalState,
370) -> WellbeingScorecardReport {
371 let refs = record_refs_from_journal(conditions, medications, diet);
372 build_scorecard_report_with_weights(refs, convergence_threshold, weight_model, state)
373}
374
375pub fn build_scorecard_report_from_journal(
377 conditions: &[JournalEntry],
378 medications: &[JournalEntry],
379 diet: &[JournalEntry],
380 convergence_threshold: usize,
381 state: PhysiologicalState,
382) -> WellbeingScorecardReport {
383 let refs = record_refs_from_journal(conditions, medications, diet);
384 build_scorecard_report(refs, convergence_threshold, state)
385}
386
387fn summary_value(entry: &JournalEntry) -> Option<serde_json::Value> {
388 serde_json::from_str(entry.summary.as_ref()?).ok()
389}
390
391fn summary_str(entry: &JournalEntry, field: &str) -> Option<String> {
392 summary_value(entry)?
393 .get(field)?
394 .as_str()
395 .map(|s| s.to_string())
396}
397
398fn summary_bool(entry: &JournalEntry, field: &str) -> Option<bool> {
399 summary_value(entry)?.get(field)?.as_bool()
400}
401
402#[cfg(test)]
403mod tests {
404 use super::*;
405 use wellfare_core::anatomy::{Aspect, ReproductiveState, Trimester};
406
407 fn je(id: &str, kind: &str, summary: serde_json::Value) -> JournalEntry {
408 JournalEntry {
409 id: id.to_string(),
410 kind: kind.to_string(),
411 asserted_time_unix: 0,
412 asserted_instant: wellfare_core::record::InstantBridge::default(),
413 evidence_type: "SelfReported".to_string(),
414 sensitivity: "Restricted".to_string(),
415 blob_hash: None,
416 source: "test".to_string(),
417 committed_unix: 0,
418 summary: Some(summary.to_string()),
419 }
420 }
421
422 #[test]
423 fn percept_parity_strain_is_redder_and_lower_pitched() {
424 let settled_sigma = burden_to_sigma(0);
426 let strained_sigma = burden_to_sigma(1000);
427 let settled = sigma_to_normalized_linear_rgba(settled_sigma);
428 let strained = sigma_to_normalized_linear_rgba(strained_sigma);
429 assert!(
431 strained[0] > strained[1] && strained[0] > strained[2],
432 "strain rgba={strained:?}"
433 );
434 assert!(settled[1] >= settled[0], "settled rgba={settled:?}");
435 assert_eq!(strained[3], 1.0, "opaque");
436 let f_settled = acoustic::sigma_to_center_frequency_hz(settled_sigma);
438 let f_strained = acoustic::sigma_to_center_frequency_hz(strained_sigma);
439 assert!(
440 f_strained < f_settled,
441 "strain {f_strained}Hz should be below settled {f_settled}Hz"
442 );
443 }
444
445 #[test]
446 fn system_percepts_cover_every_burden_and_stay_in_the_emf_band() {
447 let conditions = vec![je(
448 "did:wf:me:condition:1",
449 "condition",
450 serde_json::json!({"label": "Hypertension"}),
451 )];
452 let report = build_report_from_journal(
453 &conditions,
454 &[],
455 &[],
456 Lens::Person,
457 2,
458 PhysiologicalState::Baseline,
459 );
460 let percepts = report.system_percepts();
461 assert_eq!(percepts.len(), report.burdens.len());
463 for p in &percepts {
464 assert!(
465 p.sigma >= 0.50 - 1e-6 && p.sigma <= 0.93 + 1e-6,
466 "σ in EMF band: {}",
467 p.sigma
468 );
469 assert_eq!(p.rgba[3], 1.0);
470 assert!(p.frequency_hz > 0.0);
471 }
472 assert!(percepts.iter().any(|p| p.system_id == "circulatory"));
474 }
475
476 #[test]
477 fn paint_organs_colours_by_system_and_reports_unknown_organs() {
478 let conditions = vec![je(
479 "did:wf:me:condition:1",
480 "condition",
481 serde_json::json!({"label": "Hypertension"}),
482 )];
483 let report = build_report_from_journal(
484 &conditions,
485 &[],
486 &[],
487 Lens::Person,
488 2,
489 PhysiologicalState::Baseline,
490 );
491 let (painted, unmapped) = report.paint_organs(&[
494 "3d-vh-m-blood-vasculature.glb",
495 "3d-vh-m-lung.glb",
496 "3d-vh-m-flux-capacitor.glb",
497 ]);
498 assert_eq!(painted.len(), 2);
499 assert_eq!(unmapped, vec!["3d-vh-m-flux-capacitor.glb".to_string()]);
500
501 let circ = painted
502 .iter()
503 .find(|o| o.system_id == "circulatory")
504 .unwrap();
505 let resp = painted
506 .iter()
507 .find(|o| o.system_id == "respiratory")
508 .unwrap();
509 assert!(circ.percept.sigma >= resp.percept.sigma);
511 assert_eq!(
512 resp.percept.level,
513 WellbeingLevel::Settled,
514 "no respiratory load → settled baseline"
515 );
516 for o in &painted {
518 assert_eq!(o.percept.rgba[3], 1.0);
519 assert!(o.percept.frequency_hz > 0.0);
520 }
521 }
522
523 #[test]
524 fn overlay_percepts_surface_only_distributed_networks_with_host_hints() {
525 let burdens = vec![
526 SystemBurden {
527 system_id: "glymphatic".to_string(),
528 net_milli: 400,
529 ..Default::default()
530 },
531 SystemBurden {
532 system_id: "circulatory".to_string(),
533 net_milli: 200,
534 ..Default::default()
535 },
536 SystemBurden {
537 system_id: "ens".to_string(),
538 net_milli: 150,
539 ..Default::default()
540 },
541 ];
542 let overlays = overlay_percepts_from_burdens(&burdens);
543 assert_eq!(overlays.len(), 2);
546 assert!(overlays
547 .iter()
548 .all(|o| o.system_id == "glymphatic" || o.system_id == "ens"));
549 let ens = overlays.iter().find(|o| o.system_id == "ens").unwrap();
551 assert_eq!(ens.host_systems, vec!["digestive".to_string()]);
552 let gly = overlays
553 .iter()
554 .find(|o| o.system_id == "glymphatic")
555 .unwrap();
556 assert_eq!(gly.host_systems, vec!["nervous".to_string()]);
557 assert!(gly.percept.sigma > 0.5 && gly.percept.frequency_hz > 0.0);
559 }
560
561 #[test]
562 fn bundled_condition_map_is_embedded_and_parses() {
563 let kb = host_knowledge_base();
564 assert!(kb.get("cond:hypertension").is_some());
566 assert_eq!(
567 kb.get("cond:hypertension").unwrap().targets[0].system_id,
568 "circulatory"
569 );
570 assert!(kb.verify_integrity().is_empty());
572 }
573
574 #[test]
575 fn real_conditions_map_and_unknown_records_are_reported() {
576 let conditions = vec![
577 je(
578 "did:wf:me:condition:1",
579 "condition",
580 serde_json::json!({"label": "Hypertension"}),
581 ),
582 je(
583 "did:wf:me:condition:2",
584 "condition",
585 serde_json::json!({"label": "Made-Up Disease"}),
586 ),
587 ];
588 let meds = vec![je(
589 "did:wf:me:medication:1",
590 "medication",
591 serde_json::json!({"name": "Warfarin", "ceased": false}),
592 )];
593 let diet = vec![je(
594 "did:wf:me:diet:1",
595 "diet",
596 serde_json::json!({"description": "Beer", "meal_type": "drink"}),
597 )];
598
599 let report = build_report_from_journal(
600 &conditions,
601 &meds,
602 &diet,
603 Lens::Person,
604 1,
605 PhysiologicalState::Baseline,
606 );
607 assert!(report.burdens.iter().any(|b| b.system_id == "circulatory"));
609 assert!(report.burdens.iter().any(|b| b.system_id == "digestive"));
610 assert!(report.unmapped.iter().any(|u| u.label == "Made-Up Disease"));
611 assert!(report.unmapped.iter().any(|u| u.label == "Warfarin"));
612 assert_eq!(report.total_records, 4);
613 assert!(report.disclosure.contains("illustrative seed"));
614 assert!(report.view.boundary.contains("not medical advice"));
616 }
617
618 #[test]
619 fn ceased_medications_are_skipped() {
620 let meds = vec![je(
621 "did:wf:me:medication:old",
622 "medication",
623 serde_json::json!({"name": "Warfarin", "ceased": true}),
624 )];
625 let refs = record_refs_from_journal(&[], &meds, &[]);
626 assert!(
627 refs.is_empty(),
628 "a ceased medication is not a current factor"
629 );
630 }
631
632 #[test]
633 fn clinician_lens_flags_the_herb_drug_style_convergence() {
634 let conditions = vec![
636 je(
637 "c1",
638 "condition",
639 serde_json::json!({"label": "Hypertension"}),
640 ),
641 je(
642 "c2",
643 "condition",
644 serde_json::json!({"label": "Atrial Fibrillation"}),
645 ),
646 ];
647 let report = build_report_from_journal(
648 &conditions,
649 &[],
650 &[],
651 Lens::Clinician,
652 2,
653 PhysiologicalState::Baseline,
654 );
655 assert!(report
656 .view
657 .systems
658 .iter()
659 .any(|s| s.system_id == "circulatory"));
660 assert!(report.view.boundary.contains("not a diagnosis"));
661 }
662
663 #[test]
664 fn report_serde_round_trips() {
665 let report = build_report(vec![], Lens::Person, 2, PhysiologicalState::Baseline);
666 let json = serde_json::to_string(&report).unwrap();
667 let back: AnatomyViewReport = serde_json::from_str(&json).unwrap();
668 assert_eq!(report, back);
669 }
670
671 #[test]
672 fn scorecard_at_third_trimester_scales_adverse_load_higher_than_baseline() {
673 let refs = vec![RecordRef::new(
675 "r:renal-load",
676 "condition",
677 "Chronic Kidney Disease",
678 )];
679 let baseline_report = build_scorecard_report(refs.clone(), 1, PhysiologicalState::Baseline);
680 let preg_report = build_scorecard_report(
681 refs,
682 1,
683 PhysiologicalState::Reproductive(ReproductiveState::Pregnant(Trimester::Third)),
684 );
685 let baseline_load = baseline_report
688 .scorecard
689 .aspect(Aspect::SystemicLoad)
690 .unwrap()
691 .score_milli;
692 let preg_load = preg_report
693 .scorecard
694 .aspect(Aspect::SystemicLoad)
695 .unwrap()
696 .score_milli;
697 assert!(
698 preg_load >= baseline_load,
699 "third-trimester renal engagement scales the load up or equal: {preg_load} vs {baseline_load}"
700 );
701 let baseline_demand = baseline_report
703 .scorecard
704 .aspect(Aspect::PhysiologicalDemand)
705 .unwrap()
706 .score_milli;
707 let preg_demand = preg_report
708 .scorecard
709 .aspect(Aspect::PhysiologicalDemand)
710 .unwrap()
711 .score_milli;
712 assert_eq!(baseline_demand, 0, "baseline has no physiological demand");
713 assert!(
714 preg_demand > 0,
715 "pregnancy engages the whole body → demand > 0"
716 );
717 }
718
719 #[test]
720 fn anatomy_view_at_third_trimester_scales_circulatory_burden() {
721 let conditions = vec![je(
723 "did:wf:me:condition:1",
724 "condition",
725 serde_json::json!({"label": "Hypertension"}),
726 )];
727 let baseline_report = build_report_from_journal(
728 &conditions,
729 &[],
730 &[],
731 Lens::Person,
732 2,
733 PhysiologicalState::Baseline,
734 );
735 let preg_report = build_report_from_journal(
736 &conditions,
737 &[],
738 &[],
739 Lens::Person,
740 2,
741 PhysiologicalState::Reproductive(ReproductiveState::Pregnant(Trimester::Third)),
742 );
743 let baseline_circ = baseline_report
744 .burdens
745 .iter()
746 .find(|b| b.system_id == "circulatory")
747 .unwrap()
748 .net_milli;
749 let preg_circ = preg_report
750 .burdens
751 .iter()
752 .find(|b| b.system_id == "circulatory")
753 .unwrap()
754 .net_milli;
755 assert!(
756 preg_circ > baseline_circ,
757 "third-trimester circulatory engagement (140%) scales hypertension higher: {preg_circ} > {baseline_circ}"
758 );
759 }
760}