clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Layer 0 pure first-order guard/rule reducer (`INV-627`).

use std::borrow::Cow;
use std::rc::Rc;

use serde_json::Value;

use crate::layer0::guard_grammar::{
    ARITY_METHOD_CALL, AUTH_POLICY_LEGACY_DID, DIAG_NEGATED_GUARD_PASSED, GRAMMAR_VERSION_DIGEST,
    IDX_ARG_2, IDX_ARG_3, IDX_ARG_4, IDX_ARG_5, PRIM_ADD, PRIM_AND, PRIM_CALL, PRIM_COMPARE,
    PRIM_DIV, PRIM_FLOORDIV, PRIM_GATE, PRIM_GATE_CALL, PRIM_IN, PRIM_LIT_BOOL,
    PRIM_METHOD_CONTAINS, PRIM_METHOD_STARTSWITH, PRIM_MOD, PRIM_MUL, PRIM_NEG, PRIM_NOT,
    PRIM_NOT_IN, PRIM_OR, PRIM_POS, PRIM_REF, PRIM_RLCD_PROP, PRIM_SUB, PRIM_TRUTHY,
    PRIM_UNKNOWN_ATOM, RESOLVER_KIND_GATE, SEP_NUL, VERDICT_CHAIN, VERDICT_NOT,
};
use crate::layer0::guard_term_parser::compile_guard_term;
pub use crate::layer0::guard_term_scalar::{compare, eval_scalar};
use crate::layer0::hash::compute_blake3;
use crate::layer0::interpretation_register::{
    PH_ACTUAL, PH_DETAIL, PH_EXPECTED, PH_EXPR, PH_FIELD, PH_LEFT_EXPR, PH_OP, PH_RIGHT_EXPR,
    PH_TARGET, REGISTER_ATOM_ROWS, REGISTER_VERSION_DIGEST, ROW_DIAG_ABSENT, ROW_DIAG_FAIL,
    ROW_DIAG_UNMATCHED, ROW_RA_DIAG_ABSENT, ROW_RA_DIAG_FAIL, ROW_RUNTIMES, ROW_VERDICT_ABSENT,
    ROW_VERDICT_FALSE, ROW_VERDICT_TRUE, RUNTIME_RUST,
};
use crate::layer0::term::{render, Lit, ParseFailure, Term};
use crate::layer0::vocabulary::{
    GATE_AUTHORIZED, GUARD_FUNC_SIZE, GUARD_KIND_ABSENT, GUARD_LIT_FALSE, GUARD_LIT_NONE_CAP,
    GUARD_LIT_TRUE, GUARD_OP_NOT, GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_OUTCOME_UNMATCHED,
    GUARD_PREFIX_EXISTS, GUARD_PREFIX_TYPE, GUARD_WORD_IN, GUARD_WORD_NOT, TERM_SYNTAX_MAP_OPEN,
    TERM_SYNTAX_SPACE,
};

#[derive(Clone, Debug)]
pub enum EvalValue<'t, 'ctx> {
    TermLit(&'t Lit),
    JsonRef(&'ctx Value),
    Int(i64),
    Float(f64),
    Bool(bool),
    Str(String),
    JsonOwned(Value),
    Absent,
}

#[derive(Clone, Debug)]
pub struct FastVerdict<'a> {
    pub outcome: &'static str,
    pub reason: Cow<'a, str>,
    pub invariant_code: Cow<'a, str>,
}

pub enum ResolverReply<'ctx> {
    FieldRef(Option<&'ctx Value>),
    Field(Option<Value>),
    Gate(&'static str, String),
    GateErr(String),
    Exists(bool),
    PayloadKind(bool, Option<String>),
}

pub type ResolverFn<'a, 'ctx> = &'a mut dyn FnMut(&str, &str, &str, &[String]) -> ResolverReply<'ctx>;

pub fn compile_cache_key(expression: &str, profile: &str) -> String {
    let payload = [REGISTER_VERSION_DIGEST, SEP_NUL, GRAMMAR_VERSION_DIGEST, SEP_NUL, profile, SEP_NUL, expression].concat();
    compute_blake3(payload.as_bytes())
}

pub fn get_compiled_guard(expression: &str, profile: &str) -> Result<Rc<Term>, ParseFailure> {
    compile_guard_term(expression, profile).map(Rc::new)
}

#[inline]
pub fn find_atom_row(key: &str) -> Option<&'static [&'static str]> {
    REGISTER_ATOM_ROWS.binary_search_by_key(&key, |&(k, _)| k).ok().map(|i| REGISTER_ATOM_ROWS[i].1)
}

pub fn fmt_diag<'a>(template: &'static str, pairs: &[(&str, &str)]) -> Cow<'a, str> {
    let open_ch = TERM_SYNTAX_MAP_OPEN.chars().next().unwrap();
    if !template.contains(open_ch) {
        return Cow::Borrowed(template);
    }
    let mut out = String::with_capacity(template.len());
    let mut rest = template;
    while let Some(open) = rest.find(open_ch) {
        out.push_str(&rest[..open]);
        let after = &rest[open..];
        if let Some(&(ph, val)) = pairs.iter().find(|&&(ph, _)| after.starts_with(ph)) {
            out.push_str(val);
            rest = &after[ph.len()..];
        } else {
            out.push_str(&after[..1]);
            rest = &after[1..];
        }
    }
    out.push_str(rest);
    Cow::Owned(out)
}

#[inline]
fn intern_outcome(s: &str) -> &'static str {
    if s == GUARD_OUTCOME_PASS { GUARD_OUTCOME_PASS }
    else if s == GUARD_OUTCOME_FAIL { GUARD_OUTCOME_FAIL }
    else { GUARD_OUTCOME_UNMATCHED }
}

#[inline]
fn verdict_rank(outcome: &str) -> usize {
    if outcome == GUARD_OUTCOME_FAIL { 0 } else if outcome == GUARD_OUTCOME_PASS { IDX_ARG_2 } else { 1 }
}

#[inline]
fn pass_verdict<'a>() -> FastVerdict<'a> {
    FastVerdict { outcome: GUARD_OUTCOME_PASS, reason: Cow::Borrowed(""), invariant_code: Cow::Borrowed("") }
}

#[inline]
fn leaf_verdict<'a>(outcome: &str, reason: Cow<'a, str>, code: Cow<'a, str>, unmatched_leaf: &str) -> FastVerdict<'a> {
    let out = intern_outcome(outcome);
    if out == GUARD_OUTCOME_PASS || (out == GUARD_OUTCOME_UNMATCHED && unmatched_leaf == GUARD_OUTCOME_PASS) {
        return pass_verdict();
    }
    FastVerdict { outcome: out, reason, invariant_code: code }
}

pub fn verdict_meet<'t, F: FnOnce() -> Result<FastVerdict<'t>, String>>(left: FastVerdict<'t>, eval_right: F) -> Result<FastVerdict<'t>, String> {
    if left.outcome == GUARD_OUTCOME_FAIL { return Ok(left); }
    let right = eval_right()?;
    let target = VERDICT_CHAIN[verdict_rank(left.outcome).min(verdict_rank(right.outcome))];
    Ok(if left.outcome == target { left } else { right })
}

pub fn verdict_join<'t, F: FnOnce() -> Result<FastVerdict<'t>, String>>(left: FastVerdict<'t>, eval_right: F) -> Result<FastVerdict<'t>, String> {
    if left.outcome == GUARD_OUTCOME_PASS { return Ok(left); }
    let right = eval_right()?;
    let target = VERDICT_CHAIN[verdict_rank(left.outcome).max(verdict_rank(right.outcome))];
    Ok(if left.outcome == target { left } else { right })
}

pub fn verdict_not<'t>(inner: FastVerdict<'t>, label: &'t str) -> FastVerdict<'t> {
    let target = VERDICT_NOT.iter().find(|&&(k, _)| k == inner.outcome).map(|&(_, v)| v).unwrap_or(GUARD_OUTCOME_UNMATCHED);
    if target == GUARD_OUTCOME_PASS {
        pass_verdict()
    } else if target == GUARD_OUTCOME_FAIL {
        FastVerdict { outcome: GUARD_OUTCOME_FAIL, reason: Cow::Owned([DIAG_NEGATED_GUARD_PASSED, label].concat()), invariant_code: Cow::Owned([GUARD_OP_NOT, label].concat()) }
    } else {
        inner
    }
}

pub fn evaluate_compiled_term<'t, 'ctx>(
    term: &'t Term,
    resolver: ResolverFn<'_, 'ctx>,
    unmatched_leaf: &str,
    auth_policy: &str,
) -> Result<FastVerdict<'t>, String> {
    if let Term::Prim(name, args) = term {
        if name == PRIM_AND {
            let lv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
            return verdict_meet(lv, || evaluate_compiled_term(&args[1], resolver, unmatched_leaf, auth_policy));
        }
        if name == PRIM_OR {
            let lv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
            return verdict_join(lv, || evaluate_compiled_term(&args[1], resolver, unmatched_leaf, auth_policy));
        }
        if name == PRIM_NOT && let Some(Term::Lit(Lit::String(lbl))) = args.get(1) {
            let iv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
            return Ok(verdict_not(iv, lbl));
        }
        if name == PRIM_LIT_BOOL && let (Some(Term::Lit(Lit::Boolean(b))), Some(Term::Lit(Lit::String(raw_tok)))) = (args.first(), args.get(1)) {
            if *b { return Ok(pass_verdict()); }
            let row = find_atom_row(raw_tok).or_else(|| find_atom_row(GUARD_LIT_FALSE)).unwrap();
            let _ = GUARD_LIT_TRUE;
            return Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, raw_tok)]), Cow::Borrowed(raw_tok), unmatched_leaf));
        }
        if name == PRIM_UNKNOWN_ATOM && let Some(Term::Lit(Lit::String(raw_expr))) = args.first() {
            let row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
            return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, raw_expr)]), Cow::Borrowed(raw_expr), unmatched_leaf));
        }
        if (name == PRIM_GATE || name == PRIM_GATE_CALL) && let Some(Term::Lit(Lit::String(gate_key))) = args.first() {
            let span = args.last().and_then(|t| if let Term::Lit(Lit::String(s)) = t { Some(s.as_str()) } else { None }).unwrap_or(gate_key);
            let mut call_strs = Vec::new();
            if name == PRIM_GATE_CALL && let Some(Term::Prim(_, raw_args)) = args.get(1) {
                for a in raw_args {
                    let ev = eval_scalar(a, resolver)?;
                    if !ev.is_absent() {
                        call_strs.push(ev.display_cow().into_owned());
                    } else if let Term::Prim(rn, ra) = a && rn == PRIM_REF && let Some(Term::Lit(Lit::String(rs))) = ra.first() {
                        call_strs.push([SEP_NUL, rs].concat());
                    }
                }
            }
            let Some(row) = find_atom_row(gate_key).filter(|r| r[ROW_RUNTIMES].contains(RUNTIME_RUST)) else {
                let u_row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
                return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(u_row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            };
            return match resolver(RESOLVER_KIND_GATE, gate_key, auth_policy, &call_strs) {
                ResolverReply::GateErr(err) => Err(err),
                ResolverReply::Gate(status, detail) => {
                    let is_ra = auth_policy == AUTH_POLICY_LEGACY_DID;
                    if status == GUARD_OUTCOME_PASS {
                        Ok(leaf_verdict(row[ROW_VERDICT_TRUE], Cow::Borrowed(""), Cow::Borrowed(""), unmatched_leaf))
                    } else if status == GUARD_KIND_ABSENT {
                        let msg = if is_ra && !row[ROW_RA_DIAG_ABSENT].is_empty() { Cow::Borrowed(row[ROW_RA_DIAG_ABSENT]) } else { fmt_diag(row[ROW_DIAG_ABSENT], &[(PH_EXPR, span)]) };
                        Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], msg, Cow::Borrowed(span), unmatched_leaf))
                    } else if status == GUARD_OUTCOME_UNMATCHED {
                        let msg = fmt_diag(if row[ROW_DIAG_UNMATCHED].is_empty() { row[ROW_DIAG_ABSENT] } else { row[ROW_DIAG_UNMATCHED] }, &[(PH_EXPR, span)]);
                        Ok(if gate_key == GATE_AUTHORIZED {
                            FastVerdict { outcome: GUARD_OUTCOME_UNMATCHED, reason: msg, invariant_code: Cow::Borrowed(span) }
                        } else {
                            leaf_verdict(GUARD_OUTCOME_UNMATCHED, msg, Cow::Borrowed(span), unmatched_leaf)
                        })
                    } else {
                        let msg = if is_ra && !row[ROW_RA_DIAG_FAIL].is_empty() { Cow::Borrowed(row[ROW_RA_DIAG_FAIL]) } else { fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span), (PH_DETAIL, &detail)]) };
                        Ok(leaf_verdict(row[ROW_VERDICT_FALSE], msg, Cow::Borrowed(span), unmatched_leaf))
                    }
                }
                _ => Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, Cow::Borrowed(""), Cow::Borrowed(span), unmatched_leaf)),
            };
        }
        if (name == GUARD_PREFIX_EXISTS || name == GUARD_PREFIX_TYPE)
            && let (Some(Term::Lit(Lit::String(arg_s))), Some(Term::Lit(Lit::String(span)))) = (args.first(), args.get(1))
        {
            let row = find_atom_row(name).unwrap();
            return match resolver(name, arg_s, "", &[]) {
                ResolverReply::Exists(true) | ResolverReply::PayloadKind(true, _) => Ok(leaf_verdict(row[ROW_VERDICT_TRUE], Cow::Borrowed(""), Cow::Borrowed(""), unmatched_leaf)),
                ResolverReply::PayloadKind(false, act) => {
                    let act_s = act.as_deref().unwrap_or(GUARD_LIT_NONE_CAP);
                    Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_FIELD, arg_s), (PH_EXPECTED, arg_s), (PH_ACTUAL, act_s), (PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf))
                }
                _ => Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_FIELD, arg_s), (PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf)),
            };
        }
        if name == PRIM_COMPARE
            && let (Some(Term::Lit(Lit::String(op_s))), Some(a_rhs), Some(Term::Lit(Lit::String(l_raw))), Some(Term::Lit(Lit::String(r_raw))), Some(Term::Lit(Lit::String(span)))) =
                (args.get(1), args.get(IDX_ARG_2), args.get(IDX_ARG_3), args.get(IDX_ARG_4), args.get(IDX_ARG_5))
        {
            let lv = eval_scalar(&args[0], resolver)?;
            let rv = eval_scalar(a_rhs, resolver)?;
            let is_arith = |t: &Term| matches!(t, Term::Prim(n, _) if n == PRIM_ADD || n == PRIM_SUB || n == PRIM_MUL || n == PRIM_DIV || n == PRIM_FLOORDIV || n == PRIM_MOD || n == PRIM_NEG || n == PRIM_POS);
            if (is_arith(&args[0]) && lv.is_absent()) || (is_arith(a_rhs) && rv.is_absent()) {
                let u_row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
                return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(u_row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            }
            if compare(&lv, op_s, &rv) == GUARD_OUTCOME_PASS {
                return Ok(pass_verdict());
            }
            let (ld, rd) = (lv.display_cow(), rv.display_cow());
            if let Term::Prim(sn, sa) = &args[0] && sn == GUARD_FUNC_SIZE && let Some(Term::Lit(Lit::String(tgt))) = sa.get(1) {
                let s_row = find_atom_row(GUARD_FUNC_SIZE).unwrap();
                return Ok(leaf_verdict(GUARD_OUTCOME_FAIL, fmt_diag(s_row[ROW_DIAG_FAIL], &[(PH_TARGET, tgt), (PH_ACTUAL, &ld), (PH_OP, op_s), (PH_EXPECTED, &rd)]), Cow::Borrowed(span), unmatched_leaf));
            }
            let c_row = find_atom_row(PRIM_COMPARE).unwrap();
            return Ok(leaf_verdict(GUARD_OUTCOME_FAIL, fmt_diag(c_row[ROW_DIAG_FAIL], &[(PH_LEFT_EXPR, l_raw), (PH_ACTUAL, &ld), (PH_OP, op_s), (PH_RIGHT_EXPR, r_raw)]), Cow::Borrowed(span), unmatched_leaf));
        }
        if (name == PRIM_IN || name == PRIM_NOT_IN) && let Some(Term::Lit(Lit::String(span))) = args.get(IDX_ARG_2) {
            let lv = eval_scalar(&args[0], resolver)?;
            let rv = eval_scalar(&args[1], resolver)?;
            let row = if name == PRIM_IN { find_atom_row(GUARD_WORD_IN).unwrap() } else { find_atom_row(&[GUARD_WORD_NOT, TERM_SYNTAX_SPACE, GUARD_WORD_IN].concat()).unwrap() };
            if lv.is_absent() || rv.is_absent() {
                return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            }
            let Some(has) = rv.contains_in(&lv) else {
                return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            };
            let ok = if name == PRIM_IN { has } else { !has };
            return Ok(if ok { pass_verdict() } else { leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf) });
        }
        if name == PRIM_METHOD_CONTAINS || name == PRIM_METHOD_STARTSWITH {
            let span = args.last().and_then(|t| if let Term::Lit(Lit::String(s)) = t { Some(s.as_str()) } else { None }).unwrap_or(name);
            let row = find_atom_row(name).unwrap_or_else(|| find_atom_row(PRIM_UNKNOWN_ATOM).unwrap());
            if args.len() != ARITY_METHOD_CALL {
                return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            }
            let rv = eval_scalar(&args[0], resolver)?;
            let av = eval_scalar(&args[1], resolver)?;
            if rv.is_absent() || av.is_absent() {
                return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
            }
            let ok = if name == PRIM_METHOD_CONTAINS {
                rv.contains_in(&av).unwrap_or(false)
            } else {
                rv.as_str().zip(av.as_str()).is_some_and(|(s, sub)| s.starts_with(sub))
            };
            return Ok(if ok { pass_verdict() } else { leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf) });
        }
    }
    let ev = eval_scalar(term, resolver)?;
    let expr_label: Cow<'t, str> = match term {
        Term::Prim(n, a) if n == PRIM_REF && let Some(Term::Lit(Lit::String(s))) = a.first() => Cow::Borrowed(s),
        Term::Prim(n, a) if (n == PRIM_RLCD_PROP || n == PRIM_CALL) && let Some(Term::Lit(Lit::String(s))) = a.get(IDX_ARG_2) => Cow::Borrowed(s),
        other => Cow::Owned(render(other)),
    };
    let t_row = find_atom_row(PRIM_TRUTHY).unwrap();
    if ev.is_absent() {
        return Ok(leaf_verdict(t_row[ROW_VERDICT_ABSENT], fmt_diag(t_row[ROW_DIAG_ABSENT], &[(PH_EXPR, &expr_label)]), expr_label, unmatched_leaf));
    }
    if ev.truthy() {
        return Ok(pass_verdict());
    }
    let act_s = ev.display_cow();
    Ok(leaf_verdict(t_row[ROW_VERDICT_FALSE], fmt_diag(t_row[ROW_DIAG_FAIL], &[(PH_EXPR, &expr_label), (PH_ACTUAL, &act_s)]), expr_label, unmatched_leaf))
}