1#![allow(unused_imports)]
2use crate::layer0::vocabulary::{HANDLE_MCARD_RECEIPTS};
3use super::*;
4
5#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct ExecutionResult {
7 pub status: String,
8 pub operator: String,
9 pub outputs: HashMap<String, String>,
10 pub input_hashes: HashMap<String, String>,
11 pub output_hashes: HashMap<String, String>,
12 pub metrics: HashMap<String, Value>,
13 pub error: Option<String>,
14}
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
17pub struct Verdict {
18 pub invariant: String,
19 pub rule: String,
20 pub passed: bool,
21 pub description: Option<String>,
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct VCardReceipt {
26 pub uri: String,
27 pub hash: String,
28 pub payload: Value,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub struct HoareSandwichResult {
33 pub status: String,
34 pub action_name: String,
35 pub outputs: HashMap<String, String>,
36 pub receipt: Option<VCardReceipt>,
37 pub precondition_verdicts: Vec<Verdict>,
38 pub postcondition_verdicts: Vec<Verdict>,
39 pub rollback_occurred: bool,
40 pub rollback_time_ms: f64,
41 pub metrics: HashMap<String, Value>,
42 pub error: Option<String>,
43}
44
45fn single_output(
46 out_spec_name: Option<&str>,
47 default_name: &str,
48 val: Result<String, String>,
49) -> Result<HashMap<String, String>, String> {
50 val.map(|s| {
51 let mut m = HashMap::new();
52 m.insert(out_spec_name.unwrap_or(default_name).to_string(), s);
53 m
54 })
55}
56
57pub struct ActionDispatcher;
58
59impl ActionDispatcher {
60 pub fn execute(
61 manifest: &ActionManifest,
62 input_bindings: &HashMap<String, String>,
63 ) -> ExecutionResult {
64 Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
65 }
66
67 pub fn execute_with_clock(
68 manifest: &ActionManifest,
69 input_bindings: &HashMap<String, String>,
70 clock: impl Fn() -> std::time::Instant,
71 ) -> ExecutionResult {
72 let t_start = clock();
73 let operator = &manifest.operation.operator;
74 let params = &manifest.operation.parameters;
75
76 let mut input_hashes = HashMap::new();
77 let mut resolved_inputs = HashMap::new();
78
79 for inp in &manifest.inputs {
80 let val = input_bindings.get(&inp.name)
81 .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
82
83 if val.is_none() && inp.required {
84 return ExecutionResult {
85 status: "failed".to_string(),
86 operator: operator.to_string(),
87 outputs: HashMap::new(),
88 input_hashes,
89 output_hashes: HashMap::new(),
90 metrics: HashMap::new(),
91 error: Some(format!("Required input '{}' could not be resolved", inp.name)),
92 };
93 }
94
95 if let Some(v) = val {
96 let h = clm_hash_string(v);
97 input_hashes.insert(inp.name.clone(), h);
98 resolved_inputs.insert(inp.name.clone(), v.clone());
99 }
100 }
101
102 let primary_input = manifest
103 .inputs
104 .iter()
105 .find_map(|inp| resolved_inputs.get(&inp.name))
106 .cloned()
107 .unwrap_or_default();
108 let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
109 let first_out_name = manifest.outputs.first().map(|o| o.name.as_str());
110
111 let mut outputs = HashMap::new();
112 let mut output_hashes = HashMap::new();
113
114 let run_res: Result<HashMap<String, String>, String> = if *operator == BaldwinOperator::Custom {
115 Ok(HashMap::new())
116 } else {
117 use crate::cross_cutting::catalog_ids::{
118 op_id_for, OP_OPERATOR_DOCUMENT_AUGMENT, OP_OPERATOR_DOCUMENT_EXCLUDE,
119 OP_OPERATOR_DOCUMENT_INVERT, OP_OPERATOR_DOCUMENT_PORT, OP_OPERATOR_DOCUMENT_SPLIT,
120 OP_OPERATOR_DOCUMENT_SUBSTITUTE, OP_OPERATOR_STRUCTURED_AUGMENT,
121 OP_OPERATOR_STRUCTURED_EXCLUDE, OP_OPERATOR_STRUCTURED_INVERT,
122 OP_OPERATOR_STRUCTURED_PORT, OP_OPERATOR_STRUCTURED_SPLIT,
123 OP_OPERATOR_STRUCTURED_SUBSTITUTE, OP_OPERATOR_TABULAR_AUGMENT,
124 OP_OPERATOR_TABULAR_EXCLUDE, OP_OPERATOR_TABULAR_INVERT, OP_OPERATOR_TABULAR_PORT,
125 OP_OPERATOR_TABULAR_SPLIT, OP_OPERATOR_TABULAR_SUBSTITUTE,
126 };
127 let op_id = op_id_for(&format!("operator:{primary_format}:{operator}"))
128 .or_else(|| op_id_for(&format!("operator:structured:{operator}")));
129 match op_id {
130 Some(OP_OPERATOR_TABULAR_SPLIT) => TabularManipulator::split(&primary_input, params),
131 Some(OP_OPERATOR_TABULAR_SUBSTITUTE) => single_output(first_out_name, "output", TabularManipulator::substitute(&primary_input, params)),
132 Some(OP_OPERATOR_TABULAR_AUGMENT) => single_output(first_out_name, "augmented", TabularManipulator::augment(&primary_input, params)),
133 Some(OP_OPERATOR_TABULAR_EXCLUDE) => single_output(first_out_name, "sanitized", TabularManipulator::exclude(&primary_input, params)),
134 Some(OP_OPERATOR_TABULAR_INVERT) => single_output(first_out_name, "inverted", TabularManipulator::invert(&primary_input, params)),
135 Some(OP_OPERATOR_TABULAR_PORT) => single_output(first_out_name, "ported", TabularManipulator::port(&primary_input, params)),
136 Some(OP_OPERATOR_DOCUMENT_SPLIT) => DocumentManipulator::split(&primary_input, params),
137 Some(OP_OPERATOR_DOCUMENT_SUBSTITUTE) => single_output(first_out_name, "substituted", DocumentManipulator::substitute(&primary_input, params)),
138 Some(OP_OPERATOR_DOCUMENT_AUGMENT) => single_output(first_out_name, "augmented", DocumentManipulator::augment(&primary_input, params)),
139 Some(OP_OPERATOR_DOCUMENT_EXCLUDE) => single_output(first_out_name, "pruned", DocumentManipulator::exclude(&primary_input, params)),
140 Some(OP_OPERATOR_DOCUMENT_INVERT) => single_output(first_out_name, "inverted", DocumentManipulator::invert(&primary_input, params)),
141 Some(OP_OPERATOR_DOCUMENT_PORT) => single_output(first_out_name, "ported", DocumentManipulator::port(&primary_input, params)),
142 Some(OP_OPERATOR_STRUCTURED_SPLIT) => StructuredManipulator::split(&primary_input, params),
143 Some(OP_OPERATOR_STRUCTURED_SUBSTITUTE) => single_output(first_out_name, "substituted", StructuredManipulator::substitute(&primary_input, params)),
144 Some(OP_OPERATOR_STRUCTURED_AUGMENT) => single_output(first_out_name, "augmented", StructuredManipulator::augment(&primary_input, params)),
145 Some(OP_OPERATOR_STRUCTURED_EXCLUDE) => single_output(first_out_name, "pruned", StructuredManipulator::exclude(&primary_input, params)),
146 Some(OP_OPERATOR_STRUCTURED_INVERT) => single_output(first_out_name, "inverted", StructuredManipulator::invert(&primary_input, params)),
147 Some(OP_OPERATOR_STRUCTURED_PORT) => single_output(first_out_name, "ported", StructuredManipulator::port(&primary_input, params)),
148 _ => Err(format!("Unsupported Baldwin operator '{operator}' for format '{primary_format}'")),
149 }
150 };
151
152 match run_res {
153 Ok(res_map) => {
154 if manifest.outputs.len() > 1 && res_map.len() > 1 {
156 for out_spec in &manifest.outputs {
157 if let Some(val) = res_map.get(&out_spec.name) {
158 outputs.insert(out_spec.name.clone(), val.clone());
159 output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
160 }
161 }
162 } else if let Some(out_spec) = manifest.outputs.first() {
163 let val = res_map.get(&out_spec.name)
164 .cloned()
165 .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
166 outputs.insert(out_spec.name.clone(), val.clone());
167 output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
168 }
169
170 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
171 let mut metrics = HashMap::new();
172 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
173 metrics.insert("operator".to_string(), json!(operator.to_string()));
174 metrics.insert("action_name".to_string(), json!(manifest.clm.name));
175
176 ExecutionResult {
177 status: "success".to_string(),
178 operator: operator.to_string(),
179 outputs,
180 input_hashes,
181 output_hashes,
182 metrics,
183 error: None,
184 }
185 }
186 Err(e) => {
187 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
188 let mut metrics = HashMap::new();
189 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
190 ExecutionResult {
191 status: "failed".to_string(),
192 operator: operator.to_string(),
193 outputs: HashMap::new(),
194 input_hashes,
195 output_hashes: HashMap::new(),
196 metrics,
197 error: Some(e),
198 }
199 }
200 }
201 }
202}
203
204pub fn derive_all_passed(precondition_verdicts: &[Verdict], postcondition_verdicts: &[Verdict]) -> bool {
209 precondition_verdicts
210 .iter()
211 .chain(postcondition_verdicts.iter())
212 .all(|verdict| verdict.passed)
213}
214
215pub struct HoareSandwichEngine;
216
217impl HoareSandwichEngine {
218 pub fn execute(
219 manifest: &ActionManifest,
220 input_bindings: &HashMap<String, String>,
221 ) -> HoareSandwichResult {
222 Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
223 }
224
225 pub fn execute_with_clock(
226 manifest: &ActionManifest,
227 input_bindings: &HashMap<String, String>,
228 clock: impl Fn() -> std::time::Instant,
229 ) -> HoareSandwichResult {
230 let t_start = clock();
231 let action_manifest_val = manifest.to_canonical_json_value();
232 let action_hash = compute_canonical_hash(&action_manifest_val);
233
234 let mut pre_ctx_map = serde_json::Map::new();
236 for inp in &manifest.inputs {
237 if let Some(payload) = input_bindings.get(&inp.name) {
238 let item_ctx = build_item_context(payload);
239 pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
240 if manifest.inputs.len() == 1 || inp.name == "dataset" {
241 pre_ctx_map.insert("input".to_string(), item_ctx);
242 }
243 }
244 }
245 let pre_ctx = Value::Object(pre_ctx_map.clone());
246
247 let mut pre_verdicts = Vec::new();
249 for pre in &manifest.preconditions {
250 let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
251 let verdict = Verdict {
252 invariant: pre.invariant.clone(),
253 rule: pre.rule.clone(),
254 passed,
255 description: pre.description.clone(),
256 };
257 pre_verdicts.push(verdict);
258
259 if !passed {
260 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
261 let mut metrics = HashMap::new();
262 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
263 return HoareSandwichResult {
264 status: "failed".to_string(),
265 action_name: manifest.clm.name.clone(),
266 outputs: HashMap::new(),
267 receipt: None,
268 precondition_verdicts: pre_verdicts,
269 postcondition_verdicts: Vec::new(),
270 rollback_occurred: false,
271 rollback_time_ms: 0.0,
272 metrics,
273 error: Some(format!(
274 "Precondition '{}' violated: '{}' evaluated to false",
275 pre.invariant, pre.rule
276 )),
277 };
278 }
279 }
280
281 let exec_result = ActionDispatcher::execute_with_clock(manifest, input_bindings, &clock);
283 if exec_result.status != "success" {
284 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
285 let mut metrics = HashMap::new();
286 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
287 return HoareSandwichResult {
288 status: "failed".to_string(),
289 action_name: manifest.clm.name.clone(),
290 outputs: HashMap::new(),
291 receipt: None,
292 precondition_verdicts: pre_verdicts,
293 postcondition_verdicts: Vec::new(),
294 rollback_occurred: false,
295 rollback_time_ms: 0.0,
296 metrics,
297 error: exec_result.error,
298 };
299 }
300
301 let mut post_ctx_map = pre_ctx_map.clone();
303 let mut out_map = serde_json::Map::new();
304 for (name, payload) in &exec_result.outputs {
305 let item_ctx = build_item_context(payload);
306 out_map.insert(name.clone(), item_ctx);
307 }
308 if exec_result.outputs.len() == 1 {
309 let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
310 if let Value::Object(obj) = first_val {
311 for (k, v) in obj {
312 out_map.insert(k, v);
313 }
314 }
315 }
316 post_ctx_map.insert("output".to_string(), Value::Object(out_map));
317 let post_ctx = Value::Object(post_ctx_map);
318
319 let mut post_verdicts = Vec::new();
321 for post in &manifest.postconditions {
322 let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
323 let verdict = Verdict {
324 invariant: post.invariant.clone(),
325 rule: post.rule.clone(),
326 passed,
327 description: post.description.clone(),
328 };
329 post_verdicts.push(verdict);
330
331 if !passed {
332 let rb_start = clock();
333 let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
335 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
336 let mut metrics = HashMap::new();
337 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
338 return HoareSandwichResult {
339 status: "failed".to_string(),
340 action_name: manifest.clm.name.clone(),
341 outputs: HashMap::new(),
342 receipt: None,
343 precondition_verdicts: pre_verdicts,
344 postcondition_verdicts: post_verdicts,
345 rollback_occurred: true,
346 rollback_time_ms,
347 metrics,
348 error: Some(format!(
349 "Postcondition '{}' violated: '{}' evaluated to false",
350 post.invariant, post.rule
351 )),
352 };
353 }
354 }
355
356 let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
358 let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
359
360 let pre_digest = compute_canonical_hash(&pre_verdicts_val);
361 let post_digest = compute_canonical_hash(&post_verdicts_val);
362 let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
363 let witness_hash = clm_hash_string(&witness_preimage);
364
365 let receipt_canonical_payload = json!({
366 "archetype": "VCardReceipt",
367 "action": {
368 "name": manifest.clm.name,
369 "hash": action_hash,
370 },
371 "inputs": exec_result.input_hashes,
372 "outputs": exec_result.output_hashes,
373 "verification": {
374 "preconditions": pre_verdicts,
375 "postconditions": post_verdicts,
376 "all_passed": derive_all_passed(&pre_verdicts, &post_verdicts),
377 },
378 "witness": witness_hash,
379 });
380
381 let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
382 let receipt_uri = format!("{HANDLE_MCARD_RECEIPTS}{}", &receipt_hash[..16]);
383
384 let receipt = VCardReceipt {
385 uri: receipt_uri,
386 hash: receipt_hash,
387 payload: receipt_canonical_payload,
388 };
389
390 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
391 let mut final_metrics = exec_result.metrics.clone();
392 final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
393
394 HoareSandwichResult {
395 status: "success".to_string(),
396 action_name: manifest.clm.name.clone(),
397 outputs: exec_result.outputs,
398 receipt: Some(receipt),
399 precondition_verdicts: pre_verdicts,
400 postcondition_verdicts: post_verdicts,
401 rollback_occurred: false,
402 rollback_time_ms: 0.0,
403 metrics: final_metrics,
404 error: None,
405 }
406 }
407}
408