clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use std::path::Path;
use crate::layer0::runtime_contract::ClmExitCode;
use super::InternalFn;
use super::runtime;
use super::orchestrator_invariants::{
    prepare_context_inputs_and_check_preconditions,
    parse_outputs_and_check_postconditions,
    check_noether_and_emit_exec_mcard,
};

const POSTCONDITION_VIOLATION: &str = "Postcondition violation";
const POST_GATE_FAILED: &str = "Post-Gate Failed";
const EXIT_CODE: &str = "Exit code";
const INTERNAL_DISPATCH_ERROR: &str = "Internal dispatch error";

/// Disposes the pipeline fiber; a disposer failure is the pipeline's error.
fn dispose_fiber(fiber: &crate::fiber::Fiber) -> Result<(), String> {
    fiber.dispose().map_err(|errors| format!("fiber '{}' disposal failed: {}", fiber.id, errors.join("; ")))
}

/// Records why the pipeline aborted in the fiber, then disposes it. A refused move is the pipeline's error.
fn fail_fiber(fiber: &crate::fiber::Fiber, reason: String) -> Result<(), String> {
    fiber.transition_to(crate::fiber::FiberState::Failed(reason))?;
    dispose_fiber(fiber)
}

/// Aborts the fiber and rolls the savepoint back; the rollback runs even when the fiber refuses.
fn abort(
    fiber: &crate::fiber::Fiber,
    savepoint: &mut Option<crate::fiber::disposable::TriDbSavepointGuard>,
    reason: String,
) -> Result<(), String> {
    let aborted = fail_fiber(fiber, reason);
    if let Some(sp) = savepoint { let _ = sp.rollback(); }
    aborted
}

pub(super) struct PipelineArgs<'a> {
    pub ctx: &'a crate::fiber::Context,
    pub clm_root: &'a Path,
    pub clm_file: &'a str,
    pub payload: Option<&'a str>,
    pub post_rc: Option<i32>,
    pub quiet: bool,
    pub clm_data: &'a serde_yaml::Value,
    pub concrete_impl: &'a serde_yaml::Value,
    pub operation: &'a str,
    pub is_rust: bool,
    pub registered_func: Option<InternalFn>,
    pub module_path_opt: Option<&'a str>,
    pub process_type: &'a str,
    pub runtime_str: &'a str,
    pub skip_conditions: bool,
    pub clm_root_str: &'a str,
    pub clm_file_str: &'a str,
    pub clock_nanos: fn() -> u128,
}

pub(super) fn execute_orchestrator_pipeline(
    args: PipelineArgs,
    emit_gateway_trace: impl Fn(&str, &str, i32),
) -> Result<i32, crate::evaluator::DispatchError> {
    let mut a_mcard_opt = None;
    let has_signature = if let Some(spec) = args.clm_data.get("abstract_spec") {
        spec.get("signature").is_some()
    } else {
        args.clm_data.get("signature").is_some()
    };

    if has_signature {
        match crate::parser::parse_a_mcard(args.clm_file_str) {
            Ok(a) => a_mcard_opt = Some(a),
            Err(e) if !args.quiet => {
                eprintln!("[clmEval-rs] ⚠️ Warning: Failed to parse A-MCard spec for validation: {}", e);
            }
            _ => {}
        }
    }

    let mut context_val = serde_json::json!({ "inputs": serde_json::Value::Null, "outputs": serde_json::Value::Null });
    if let Some(ref a_mcard) = a_mcard_opt {
        let concrete_args = super::get_clm_args(args.clm_file_str).unwrap_or_default();
        match prepare_context_inputs_and_check_preconditions(
            a_mcard, &concrete_args, args.payload, args.skip_conditions, args.clm_root_str, args.quiet,
        ) {
            Ok(ctx) => context_val = ctx,
            Err(_) => return Ok(ClmExitCode::PreconditionOrBoundaryViolation.code()),
        }
    }

    let isolated_ctx = args.ctx.isolate(&[crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, crate::layer0::vocabulary_env::PILLAR_AGENT_IDENTITIES, crate::layer0::vocabulary_env::PILLAR_EXECUTION_LOG]);
    let fiber_id = format!("fiber_{}_{:x}", args.clm_file.replace(['/', '.'], "_"), rand::random::<u16>());
    let fiber = isolated_ctx.spawn_fiber(&fiber_id, vec![]);
    fiber.transition_to(crate::fiber::FiberState::Active)?;

    let sp_token = format!("sp_{}_{:x}", (args.clock_nanos)(), rand::random::<u32>());
    let mut tri_sp = crate::fiber::disposable::TriDbSavepointGuard::with_pillars(args.clm_root_str, &sp_token, &[crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, crate::layer0::vocabulary_env::PILLAR_AGENT_IDENTITIES]).ok();

    emit_gateway_trace(&format!("execute:{}", args.operation), "exec", 0);
    let run_res = if args.is_rust {
        match args.registered_func {
            Some(f) => f(args.clm_root_str, args.clm_file_str).map_err(Into::into),
            None => {
                let m_path = args.module_path_opt.unwrap_or("");
                if !args.quiet {
                    eprintln!("[clmEval-rs] ⚡ Sourcing shell test fallback for unregistered module: {}", m_path);
                }
                runtime::run_fallback_internal_reference(args.clm_root_str, args.clm_file_str, m_path, args.quiet)
                    .map_err(Into::into)
            }
        }
    } else {
        runtime::evaluate_non_rust_runtime(args.clm_root, args.clm_file, args.process_type, args.runtime_str, args.concrete_impl, args.payload, args.post_rc, args.quiet, args.clock_nanos)
    };

    match run_res {
        Ok((exit_code, output)) => {
            let nested_exec = crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_NESTED_EXEC).unwrap_or_default() == "1";
            let is_user_script = !args.is_rust && !args.operation.starts_with("test_");
            if !output.is_empty() && (!args.quiet || nested_exec || is_user_script) {
                print!("{}", output);
            }

            if exit_code == 0 {
                if let Some(ref a_mcard) = a_mcard_opt {
                    if parse_outputs_and_check_postconditions(
                        a_mcard, &output, &mut context_val, args.skip_conditions, args.clm_root_str, args.quiet,
                    ).is_err() {
                        abort(&fiber, &mut tri_sp, POSTCONDITION_VIOLATION.to_string())?;
                        return Ok(ClmExitCode::PostconditionOrCycleViolation.code());
                    }
                }
                check_noether_and_emit_exec_mcard(args.operation, &output, args.clm_data, args.clm_root_str, args.quiet);
            }

            if !args.skip_conditions {
                emit_gateway_trace("validate_postcondition", "post", exit_code);
                match crate::evaluator::compose::compose_conditions_dispatch(args.clm_root, args.clm_file, "post", exit_code, args.quiet) {
                    Ok(0) => {}
                    Ok(rc) => {
                        eprintln!("CRITICAL: Post-Gate Failed.");
                        abort(&fiber, &mut tri_sp, POST_GATE_FAILED.to_string())?;
                        return Ok(rc);
                    }
                    Err(e @ crate::evaluator::DispatchError::SovereignSubprocessForbidden(_)) => {
                        abort(&fiber, &mut tri_sp, format!("{POST_GATE_FAILED}: {e}")).map_err(|refused| crate::evaluator::DispatchError::Other(format!("{e}; {refused}")))?;
                        return Err(e);
                    }
                    Err(e) => {
                        eprintln!("CRITICAL: Post-Gate Failed: {}", e);
                        abort(&fiber, &mut tri_sp, format!("{POST_GATE_FAILED}: {e}"))?;
                        return Ok(ClmExitCode::PostconditionOrCycleViolation.code());
                    }
                }
            }

            if let Some(ref mut sp) = tri_sp {
                if exit_code == 0 { let _ = sp.commit(); } else { let _ = sp.rollback(); }
            }

            if exit_code == 0 {
                dispose_fiber(&fiber)?;
            } else {
                fail_fiber(&fiber, format!("{EXIT_CODE} {exit_code}"))?;
            }

            emit_gateway_trace("vcard_seal", "seal", exit_code);
            Ok(exit_code)
        }
        Err(e @ crate::evaluator::DispatchError::SovereignSubprocessForbidden(_)) => {
            abort(&fiber, &mut tri_sp, format!("{INTERNAL_DISPATCH_ERROR}: {e}")).map_err(|refused| crate::evaluator::DispatchError::Other(format!("{e}; {refused}")))?;
            Err(e)
        }
        Err(e) => {
            eprintln!("[clmEval-rs] ❌ {INTERNAL_DISPATCH_ERROR}: {}", e);
            abort(&fiber, &mut tri_sp, format!("{INTERNAL_DISPATCH_ERROR}: {e}"))?;
            Ok(ClmExitCode::GeneralError.code())
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::fiber::{Fiber, FiberState};

    #[test]
    fn fail_fiber_records_the_reason_then_disposes() {
        let fiber = Fiber::new("pipeline", vec![]);
        assert_eq!(fail_fiber(&fiber, format!("{EXIT_CODE} 3")), Ok(()));
        assert_eq!(fiber.get_state(), FiberState::Disposed);
    }

    #[test]
    fn a_fiber_that_refuses_the_abort_fails_the_pipeline() {
        let fiber = Fiber::new("pipeline", vec![]);
        fiber.dispose().unwrap();

        let refused = abort(&fiber, &mut None, POST_GATE_FAILED.to_string()).unwrap_err();
        assert!(refused.starts_with("illegal fiber transition disposed -> failed"), "{refused}");
        let refused = fail_fiber(&fiber, POSTCONDITION_VIOLATION.to_string()).unwrap_err();
        assert!(refused.starts_with("illegal fiber transition disposed -> failed"), "{refused}");
    }

    #[test]
    fn a_failing_disposer_fails_the_pipeline() {
        let disposed = Fiber::new("pipeline", vec![]);
        disposed.register_disposable(|| Err("handle leaked".to_string()));
        assert_eq!(dispose_fiber(&disposed), Err("fiber 'pipeline' disposal failed: handle leaked".to_string()));

        let aborted = Fiber::new("pipeline", vec![]);
        aborted.register_disposable(|| Err("handle leaked".to_string()));
        let reason = format!("{INTERNAL_DISPATCH_ERROR}: boom");
        assert_eq!(abort(&aborted, &mut None, reason), Err("fiber 'pipeline' disposal failed: handle leaked".to_string()));
    }
}