use crate::layer0::vocabulary::{HASH_PREFIX_SHA256};
use serde_json::Value;
use crate::fs_utils::compute_sha256_hex;
use crate::parser::AMCard;
pub(super) fn prepare_context_inputs_and_check_preconditions(
a_mcard: &AMCard,
concrete_args: &[String],
payload: Option<&str>,
skip_conditions: bool,
clm_root_str: &str,
quiet: bool,
) -> Result<Value, String> {
let mut context_val = serde_json::json!({ "inputs": Value::Null, "outputs": Value::Null });
let mut inputs_map = serde_json::Map::new();
let mut payload_parsed = false;
if let Some(pay) = payload {
let trimmed = pay.trim();
if trimmed.starts_with('{') {
if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
for (k, v) in obj { inputs_map.insert(k, v); }
payload_parsed = true;
}
} else if trimmed.contains(':')
&& let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
&& let Value::Object(obj) = data {
for (k, v) in obj { inputs_map.insert(k, v); }
payload_parsed = true;
}
}
if !payload_parsed && let Some(pay) = payload
&& let Value::Object(ref sig_inputs) = a_mcard.signature.inputs && sig_inputs.len() == 1 {
let first_key = sig_inputs.keys().next().unwrap();
if let Ok(num) = pay.parse::<i64>() { inputs_map.insert(first_key.clone(), Value::from(num)); }
else if let Ok(f) = pay.parse::<f64>() { inputs_map.insert(first_key.clone(), Value::from(f)); }
else if pay == "true" { inputs_map.insert(first_key.clone(), Value::Bool(true)); }
else if pay == "false" { inputs_map.insert(first_key.clone(), Value::Bool(false)); }
else { inputs_map.insert(first_key.clone(), Value::String(pay.to_string())); }
}
if let Value::Object(ref sig_inputs) = a_mcard.signature.inputs {
let keys: Vec<&String> = sig_inputs.keys().collect();
for (i, key) in keys.iter().enumerate() {
if !inputs_map.contains_key(*key) && let Some(arg) = concrete_args.get(i) {
if let Ok(num) = arg.parse::<i64>() { inputs_map.insert((*key).clone(), Value::from(num)); }
else if let Ok(f) = arg.parse::<f64>() { inputs_map.insert((*key).clone(), Value::from(f)); }
else if arg == "true" { inputs_map.insert((*key).clone(), Value::Bool(true)); }
else if arg == "false" { inputs_map.insert((*key).clone(), Value::Bool(false)); }
else { inputs_map.insert((*key).clone(), Value::String(arg.clone())); }
}
}
}
if let Some(obj) = context_val.as_object_mut() {
obj.insert("inputs".to_string(), Value::Object(inputs_map));
let resolved_payload = payload
.map(str::to_string)
.or_else(|| crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_PAYLOAD).ok())
.unwrap_or_default();
obj.insert("payload".to_string(), Value::String(resolved_payload));
}
if !skip_conditions {
for pre in &a_mcard.invariants.preconditions {
match crate::invariants::evaluate_invariant(pre, clm_root_str, &context_val) {
Ok(true) => {
if !quiet { eprintln!("[VCARD PRE] Invariant '{}' satisfied.", pre); }
}
Ok(false) => {
eprintln!("[PREP_ERR] Precondition violation: Invariant '{}' failed.", pre);
return Err(format!("Precondition violation: {}", pre));
}
Err(e) => {
eprintln!("[PREP_ERR] Precondition check error: Invariant '{}' raised error: {}", pre, e);
return Err(format!("Precondition check error: {}", e));
}
}
}
}
Ok(context_val)
}
pub(super) fn parse_outputs_and_check_postconditions(
a_mcard: &AMCard,
output: &str,
context_val: &mut Value,
skip_conditions: bool,
clm_root_str: &str,
quiet: bool,
) -> Result<(), String> {
let mut outputs_map = serde_json::Map::new();
let trimmed = output.trim();
let mut parsed = false;
if trimmed.starts_with('{') {
if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
for (k, v) in obj { outputs_map.insert(k, v); }
parsed = true;
}
} else if trimmed.contains(':')
&& let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
&& let Value::Object(obj) = data {
for (k, v) in obj { outputs_map.insert(k, v); }
parsed = true;
}
if !parsed && let Value::Object(ref sig_outputs) = a_mcard.signature.outputs && sig_outputs.len() == 1 {
let first_key = sig_outputs.keys().next().unwrap();
if let Ok(num) = trimmed.parse::<i64>() { outputs_map.insert(first_key.clone(), Value::from(num)); }
else if let Ok(f) = trimmed.parse::<f64>() { outputs_map.insert(first_key.clone(), Value::from(f)); }
else if trimmed == "true" { outputs_map.insert(first_key.clone(), Value::Bool(true)); }
else if trimmed == "false" { outputs_map.insert(first_key.clone(), Value::Bool(false)); }
else { outputs_map.insert(first_key.clone(), Value::String(trimmed.to_string())); }
}
if !outputs_map.contains_key("a_hash") && let Ok(h) = crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_ACTIVE_A_HASH) {
outputs_map.insert("a_hash".to_string(), Value::String(h));
}
if !outputs_map.contains_key("c_hash") && let Ok(h) = crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_ACTIVE_C_HASH) {
outputs_map.insert("c_hash".to_string(), Value::String(h));
}
if !outputs_map.contains_key("b_hash") && let Ok(h) = crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_ACTIVE_B_HASH) {
outputs_map.insert("b_hash".to_string(), Value::String(h));
}
if let Some(obj) = context_val.as_object_mut() {
obj.insert("outputs".to_string(), Value::Object(outputs_map));
}
if !skip_conditions {
for post in &a_mcard.invariants.postconditions {
match crate::invariants::evaluate_invariant(post, clm_root_str, context_val) {
Ok(true) => {
if !quiet { eprintln!("[VCARD POST] Invariant '{}' satisfied.", post); }
}
Ok(false) => {
eprintln!("[POST_ERR] Postcondition violation: Invariant '{}' failed.", post);
return Err(format!("Postcondition violation: {}", post));
}
Err(e) => {
eprintln!("[POST_ERR] Postcondition check error: Invariant '{}' raised error: {}", post, e);
return Err(format!("Postcondition check error: {}", e));
}
}
}
}
Ok(())
}
pub(super) fn check_noether_and_emit_exec_mcard(
operation: &str,
output: &str,
clm_data: &serde_yaml::Value,
clm_root_str: &str,
quiet: bool,
) {
let raw_hex = compute_sha256_hex(output.as_bytes());
let output_hash = format!("{HASH_PREFIX_SHA256}{}", raw_hex);
let a_hash_str = clm_data.get("_meta").and_then(|m| m.get("a_hash")).and_then(|v| v.as_str())
.map(|s| s.to_string())
.unwrap_or_else(|| {
let spec = clm_data.get("abstract_spec").cloned().unwrap_or(serde_yaml::Value::Null);
let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
format!("{HASH_PREFIX_SHA256}{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
});
let c_hash_str = clm_data.get("_meta").and_then(|m| m.get("c_hash")).and_then(|v| v.as_str())
.map(|s| s.to_string())
.unwrap_or_else(|| {
let spec = clm_data.get("concrete_impl").cloned().unwrap_or(serde_yaml::Value::Null);
let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
format!("{HASH_PREFIX_SHA256}{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
});
let inputs_len = clm_data.get("concrete_impl").and_then(|v| v.get("inputs")).and_then(|v| v.as_sequence()).map(|a| a.len()).unwrap_or(0);
let outputs_len = clm_data.get("concrete_impl").and_then(|v| v.get("outputs")).and_then(|v| v.as_sequence()).map(|a| a.len()).unwrap_or(0);
let x_t_d = (outputs_len as i32) - (inputs_len as i32);
if !quiet {
eprintln!("[VCARD POST] 🔍 Noetherian P-invariant conservation check: x^T D = 0");
if x_t_d == 0 {
eprintln!(" ✅ P-Inv: place marking conservation holds (x^T D = 0) [OK]");
} else {
eprintln!(" ⚠️ P-Inv: place marking conservation drift detected: x^T D = {} (inputs={}, outputs={})", x_t_d, inputs_len, outputs_len);
}
}
let extra_yaml = format!("content: |\n {}", output.replace('\n', "\n "));
match crate::db::emit_exec_mcard(
operation, &output_hash, &extra_yaml, &a_hash_str, &c_hash_str, clm_root_str,
) {
Ok(exec_mcard_path) => {
if !quiet {
eprintln!("[VCARD POST] ✅ Execution MCard generated: {}", exec_mcard_path);
eprintln!("[VCARD POST] g_time: {}", crate::fs_utils::compute_g_time());
eprintln!("[VCARD POST] content_hash: {}", raw_hex);
}
}
Err(e) => {
eprintln!("[VCARD POST] ❌ Failed to emit execution MCard: {}", e);
}
}
}