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
45pub struct ActionDispatcher;
46
47impl ActionDispatcher {
48 pub fn execute(
49 manifest: &ActionManifest,
50 input_bindings: &HashMap<String, String>,
51 ) -> ExecutionResult {
52 let t_start = std::time::Instant::now();
53 let operator = &manifest.operation.operator;
54 let params = &manifest.operation.parameters;
55
56 let mut input_hashes = HashMap::new();
57 let mut resolved_inputs = HashMap::new();
58
59 for inp in &manifest.inputs {
60 let val = input_bindings.get(&inp.name)
61 .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
62
63 if val.is_none() && inp.required {
64 return ExecutionResult {
65 status: "failed".to_string(),
66 operator: operator.to_string(),
67 outputs: HashMap::new(),
68 input_hashes,
69 output_hashes: HashMap::new(),
70 metrics: HashMap::new(),
71 error: Some(format!("Required input '{}' could not be resolved", inp.name)),
72 };
73 }
74
75 if let Some(v) = val {
76 let h = clm_hash_string(v);
77 input_hashes.insert(inp.name.clone(), h);
78 resolved_inputs.insert(inp.name.clone(), v.clone());
79 }
80 }
81
82 let primary_input = resolved_inputs.values().next().cloned().unwrap_or_default();
83 let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
84
85 let mut outputs = HashMap::new();
86 let mut output_hashes = HashMap::new();
87
88 let run_res: Result<HashMap<String, String>, String> = match primary_format.as_str() {
89 "csv" | "tabular" => {
90 match operator {
91 BaldwinOperator::Split => TabularManipulator::split(&primary_input, params),
92 BaldwinOperator::Substitute => TabularManipulator::substitute(&primary_input, params).map(|s| {
93 let mut m = HashMap::new();
94 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "output".to_string());
95 m.insert(out_name, s);
96 m
97 }),
98 BaldwinOperator::Augment => TabularManipulator::augment(&primary_input, params).map(|s| {
99 let mut m = HashMap::new();
100 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
101 m.insert(out_name, s);
102 m
103 }),
104 BaldwinOperator::Exclude => TabularManipulator::exclude(&primary_input, params).map(|s| {
105 let mut m = HashMap::new();
106 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "sanitized".to_string());
107 m.insert(out_name, s);
108 m
109 }),
110 BaldwinOperator::Invert => TabularManipulator::invert(&primary_input, params).map(|s| {
111 let mut m = HashMap::new();
112 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
113 m.insert(out_name, s);
114 m
115 }),
116 BaldwinOperator::Port => TabularManipulator::port(&primary_input, params).map(|s| {
117 let mut m = HashMap::new();
118 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
119 m.insert(out_name, s);
120 m
121 }),
122 BaldwinOperator::Custom => Ok(HashMap::new()),
123 }
124 }
125 "markdown" | "text" | "md" => {
126 match operator {
127 BaldwinOperator::Split => DocumentManipulator::split(&primary_input, params),
128 BaldwinOperator::Substitute => DocumentManipulator::substitute(&primary_input, params).map(|s| {
129 let mut m = HashMap::new();
130 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
131 m.insert(out_name, s);
132 m
133 }),
134 BaldwinOperator::Augment => DocumentManipulator::augment(&primary_input, params).map(|s| {
135 let mut m = HashMap::new();
136 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
137 m.insert(out_name, s);
138 m
139 }),
140 BaldwinOperator::Exclude => DocumentManipulator::exclude(&primary_input, params).map(|s| {
141 let mut m = HashMap::new();
142 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
143 m.insert(out_name, s);
144 m
145 }),
146 BaldwinOperator::Invert => DocumentManipulator::invert(&primary_input, params).map(|s| {
147 let mut m = HashMap::new();
148 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
149 m.insert(out_name, s);
150 m
151 }),
152 BaldwinOperator::Port => DocumentManipulator::port(&primary_input, params).map(|s| {
153 let mut m = HashMap::new();
154 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
155 m.insert(out_name, s);
156 m
157 }),
158 BaldwinOperator::Custom => Ok(HashMap::new()),
159 }
160 }
161 _ => { match operator {
163 BaldwinOperator::Split => StructuredManipulator::split(&primary_input, params),
164 BaldwinOperator::Substitute => StructuredManipulator::substitute(&primary_input, params).map(|s| {
165 let mut m = HashMap::new();
166 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "substituted".to_string());
167 m.insert(out_name, s);
168 m
169 }),
170 BaldwinOperator::Augment => StructuredManipulator::augment(&primary_input, params).map(|s| {
171 let mut m = HashMap::new();
172 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "augmented".to_string());
173 m.insert(out_name, s);
174 m
175 }),
176 BaldwinOperator::Exclude => StructuredManipulator::exclude(&primary_input, params).map(|s| {
177 let mut m = HashMap::new();
178 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "pruned".to_string());
179 m.insert(out_name, s);
180 m
181 }),
182 BaldwinOperator::Invert => StructuredManipulator::invert(&primary_input, params).map(|s| {
183 let mut m = HashMap::new();
184 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "inverted".to_string());
185 m.insert(out_name, s);
186 m
187 }),
188 BaldwinOperator::Port => StructuredManipulator::port(&primary_input, params).map(|s| {
189 let mut m = HashMap::new();
190 let out_name = manifest.outputs.first().map(|o| o.name.clone()).unwrap_or_else(|| "ported".to_string());
191 m.insert(out_name, s);
192 m
193 }),
194 BaldwinOperator::Custom => Ok(HashMap::new()),
195 }
196 }
197 };
198
199 match run_res {
200 Ok(res_map) => {
201 if manifest.outputs.len() > 1 && res_map.len() > 1 {
203 for out_spec in &manifest.outputs {
204 if let Some(val) = res_map.get(&out_spec.name) {
205 outputs.insert(out_spec.name.clone(), val.clone());
206 output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
207 }
208 }
209 } else if let Some(out_spec) = manifest.outputs.first() {
210 let val = res_map.get(&out_spec.name)
211 .cloned()
212 .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
213 outputs.insert(out_spec.name.clone(), val.clone());
214 output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
215 }
216
217 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
218 let mut metrics = HashMap::new();
219 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
220 metrics.insert("operator".to_string(), json!(operator.to_string()));
221 metrics.insert("action_name".to_string(), json!(manifest.clm.name));
222
223 ExecutionResult {
224 status: "success".to_string(),
225 operator: operator.to_string(),
226 outputs,
227 input_hashes,
228 output_hashes,
229 metrics,
230 error: None,
231 }
232 }
233 Err(e) => {
234 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
235 let mut metrics = HashMap::new();
236 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
237 ExecutionResult {
238 status: "failed".to_string(),
239 operator: operator.to_string(),
240 outputs: HashMap::new(),
241 input_hashes,
242 output_hashes: HashMap::new(),
243 metrics,
244 error: Some(e),
245 }
246 }
247 }
248 }
249}
250
251pub struct HoareSandwichEngine;
252
253impl HoareSandwichEngine {
254 pub fn execute(
255 manifest: &ActionManifest,
256 input_bindings: &HashMap<String, String>,
257 ) -> HoareSandwichResult {
258 let t_start = std::time::Instant::now();
259 let action_manifest_val = manifest.to_canonical_json_value();
260 let action_hash = compute_canonical_hash(&action_manifest_val);
261
262 let mut pre_ctx_map = serde_json::Map::new();
264 for inp in &manifest.inputs {
265 if let Some(payload) = input_bindings.get(&inp.name) {
266 let item_ctx = build_item_context(payload);
267 pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
268 if manifest.inputs.len() == 1 || inp.name == "dataset" {
269 pre_ctx_map.insert("input".to_string(), item_ctx);
270 }
271 }
272 }
273 let pre_ctx = Value::Object(pre_ctx_map.clone());
274
275 let mut pre_verdicts = Vec::new();
277 for pre in &manifest.preconditions {
278 let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
279 let verdict = Verdict {
280 invariant: pre.invariant.clone(),
281 rule: pre.rule.clone(),
282 passed,
283 description: pre.description.clone(),
284 };
285 pre_verdicts.push(verdict);
286
287 if !passed {
288 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
289 let mut metrics = HashMap::new();
290 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
291 return HoareSandwichResult {
292 status: "failed".to_string(),
293 action_name: manifest.clm.name.clone(),
294 outputs: HashMap::new(),
295 receipt: None,
296 precondition_verdicts: pre_verdicts,
297 postcondition_verdicts: Vec::new(),
298 rollback_occurred: false,
299 rollback_time_ms: 0.0,
300 metrics,
301 error: Some(format!(
302 "Precondition '{}' violated: '{}' evaluated to false",
303 pre.invariant, pre.rule
304 )),
305 };
306 }
307 }
308
309 let exec_result = ActionDispatcher::execute(manifest, input_bindings);
311 if exec_result.status != "success" {
312 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
313 let mut metrics = HashMap::new();
314 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
315 return HoareSandwichResult {
316 status: "failed".to_string(),
317 action_name: manifest.clm.name.clone(),
318 outputs: HashMap::new(),
319 receipt: None,
320 precondition_verdicts: pre_verdicts,
321 postcondition_verdicts: Vec::new(),
322 rollback_occurred: false,
323 rollback_time_ms: 0.0,
324 metrics,
325 error: exec_result.error,
326 };
327 }
328
329 let mut post_ctx_map = pre_ctx_map.clone();
331 let mut out_map = serde_json::Map::new();
332 for (name, payload) in &exec_result.outputs {
333 let item_ctx = build_item_context(payload);
334 out_map.insert(name.clone(), item_ctx);
335 }
336 if exec_result.outputs.len() == 1 {
337 let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
338 if let Value::Object(obj) = first_val {
339 for (k, v) in obj {
340 out_map.insert(k, v);
341 }
342 }
343 }
344 post_ctx_map.insert("output".to_string(), Value::Object(out_map));
345 let post_ctx = Value::Object(post_ctx_map);
346
347 let mut post_verdicts = Vec::new();
349 for post in &manifest.postconditions {
350 let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
351 let verdict = Verdict {
352 invariant: post.invariant.clone(),
353 rule: post.rule.clone(),
354 passed,
355 description: post.description.clone(),
356 };
357 post_verdicts.push(verdict);
358
359 if !passed {
360 let rb_start = std::time::Instant::now();
361 let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
363 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
364 let mut metrics = HashMap::new();
365 metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
366 return HoareSandwichResult {
367 status: "failed".to_string(),
368 action_name: manifest.clm.name.clone(),
369 outputs: HashMap::new(),
370 receipt: None,
371 precondition_verdicts: pre_verdicts,
372 postcondition_verdicts: post_verdicts,
373 rollback_occurred: true,
374 rollback_time_ms,
375 metrics,
376 error: Some(format!(
377 "Postcondition '{}' violated: '{}' evaluated to false",
378 post.invariant, post.rule
379 )),
380 };
381 }
382 }
383
384 let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
386 let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
387
388 let pre_digest = compute_canonical_hash(&pre_verdicts_val);
389 let post_digest = compute_canonical_hash(&post_verdicts_val);
390 let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
391 let witness_hash = clm_hash_string(&witness_preimage);
392
393 let receipt_canonical_payload = json!({
394 "archetype": "VCardReceipt",
395 "action": {
396 "name": manifest.clm.name,
397 "hash": action_hash,
398 },
399 "inputs": exec_result.input_hashes,
400 "outputs": exec_result.output_hashes,
401 "verification": {
402 "preconditions": pre_verdicts,
403 "postconditions": post_verdicts,
404 "all_passed": true,
405 },
406 "witness": witness_hash,
407 });
408
409 let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
410 let receipt_uri = format!("{HANDLE_MCARD_RECEIPTS}{}", &receipt_hash[..16]);
411
412 let receipt = VCardReceipt {
413 uri: receipt_uri,
414 hash: receipt_hash,
415 payload: receipt_canonical_payload,
416 };
417
418 let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
419 let mut final_metrics = exec_result.metrics.clone();
420 final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
421
422 HoareSandwichResult {
423 status: "success".to_string(),
424 action_name: manifest.clm.name.clone(),
425 outputs: exec_result.outputs,
426 receipt: Some(receipt),
427 precondition_verdicts: pre_verdicts,
428 postcondition_verdicts: post_verdicts,
429 rollback_occurred: false,
430 rollback_time_ms: 0.0,
431 metrics: final_metrics,
432 error: None,
433 }
434 }
435}
436