arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/rs/Cargo.lock

@@ -0,0 +1,142 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "arxo-codegen-rust-dependencies"
+version = "0.1.0"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "serde_json",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "num-bigint"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

arxo_codegen/targets/rs/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "arxo-codegen-rust-dependencies"
+version = "0.1.0"
+edition = "2021"
+autobins = false
+
+[lib]
+path = "prefetch.rs"
+
+# This manifest exists solely to prefetch the exact crates used by generated
+# projects before their descriptors build with `cargo --offline` in CI.
+[dependencies]
+num-bigint = "0.4"
+num-integer = "0.1"
+num-traits = "0.2"
+serde_json = { version = "1", features = ["arbitrary_precision"] }

arxo_codegen/targets/rs/cert.rs

@@ -0,0 +1,106 @@
+//! Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+//! что получилось. Ожидания сверяют ворота, харнесс их не читает.
+mod rt;
+
+use num_bigint::BigInt;
+use num_traits::Signed;
+use rt::{Refused, Val, R};
+use serde_json::{json, Value};
+
+fn lit(x: &Value) -> Val {
+    if let Some(s) = x.as_str() {
+        return rt::text(s);
+    }
+    if let Some(d) = x.get("dec") {
+        return rt::dec(d.as_str().unwrap());
+    }
+    if let Some(m) = x.get("money") {
+        return rt::money(m.as_str().unwrap(), x["cur"].as_str().unwrap());
+    }
+    if let Some(t) = x.get("text") {
+        return rt::text(t.as_str().unwrap());
+    }
+    if let Some(d) = x.get("date") {
+        return rt::date(d.as_str().unwrap());
+    }
+    if let Some(s) = x.get("sym") {
+        return rt::sym(s.as_str().unwrap());
+    }
+    panic!("литерал фикстуры: {x}");
+}
+
+fn row(x: &Value) -> Vec<Val> {
+    x["row"].as_array().unwrap().iter().map(lit).collect()
+}
+
+/// Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+fn digits(u: &BigInt, s: usize) -> String {
+    let neg = u.is_negative();
+    let mut body = u.abs().to_string();
+    while body.len() < s + 1 {
+        body.insert(0, '0');
+    }
+    let text = if s == 0 {
+        body
+    } else {
+        let cut = body.len() - s;
+        format!("{}.{}", &body[..cut], &body[cut..])
+    };
+    if neg { format!("-{text}") } else { text }
+}
+
+fn render(v: &Val) -> Value {
+    match v {
+        Val::Text(t) => json!(t),
+        Val::Money { u, s, cur } => json!(format!("{} {}", digits(u, *s), cur)),
+        Val::Dec { u, s } => json!(digits(u, *s)),
+        Val::Date(d) => json!(d),
+        Val::Sym(s) => json!(s),
+    }
+}
+
+fn run(db: &mut rt::Db, c: &Value) -> R<Value> {
+    let a: Vec<Value> = c["args"].as_array().unwrap().clone();
+    let s = |i: usize| a[i].as_str().unwrap();
+    let v = |i: usize| lit(&a[i]);
+    Ok(match c["op"].as_str().unwrap() {
+        "dec" => render(&rt::dec(s(0))),
+        "money" => render(&rt::money(s(0), s(1))),
+        "date" => render(&rt::date(s(0))),
+        "sym" => render(&rt::sym(s(0))),
+        "add" => render(&rt::add(&v(0), &v(1))?),
+        "sub" => render(&rt::sub(&v(0), &v(1))?),
+        "mul" => render(&rt::mul(&v(0), &v(1))?),
+        "div" => render(&rt::div(&v(0), &v(1))?),
+        "mod" => render(&rt::modulo(&v(0), &v(1))?),
+        "min" => render(&rt::min(&v(0), &v(1))?),
+        "max" => render(&rt::max(&v(0), &v(1))?),
+        "abs" => render(&rt::abs(&v(0))?),
+        "pow" => render(&rt::pow(&v(0), &v(1))?),
+        "round" => render(&rt::round(&v(0), &v(1), s(2))?),
+        "cmp" => json!(rt::cmp(&v(0), s(1), &v(2))?),
+        "eq" => json!(rt::eq(&v(0), &v(1))),
+        "keyEq" => json!(rt::key(&row(&a[0])) == rt::key(&row(&a[1]))),
+        "legalTime" => json!(db.legal_time()?),
+        "setLegalTime" => {
+            db.set_legal_time(s(0));
+            Value::Null
+        }
+        op => panic!("неизвестная операция фикстуры: {op}"),
+    })
+}
+
+fn main() {
+    let argv: Vec<String> = std::env::args().collect();
+    let fixture: Value = serde_json::from_str(&std::fs::read_to_string(&argv[1]).unwrap()).unwrap();
+    let mut db = rt::Db::new(&[]);
+    let mut out = Vec::new();
+    for c in fixture["cases"].as_array().unwrap() {
+        let got = match run(&mut db, c) {
+            Ok(v) => v,
+            Err(Refused(msg)) => json!({ "refused": msg }),
+        };
+        out.push(json!({ "id": c["id"], "got": got }));
+    }
+    println!("{}", serde_json::to_string(&out).unwrap());
+}

arxo_codegen/targets/rs/emit.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Эмиттер Rust. Тот же план; модель — модуль `model.rs` с таблицами,
+правилами над `rt::Db` и `Result` вместо panic."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+OPS = {"add": "add", "sub": "sub", "mul": "mul", "div": "div", "mod": "modulo"}
+
+
+def key_readers(plan: dict) -> dict[str, list[str]]:
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(rule["head"]["pred"])
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(rule["head"]["pred"])
+    return {source: sorted(consumers) for source, consumers in sorted(readers.items())}
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}].clone()'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'rt::money("{t["v"]}", "{t["cur"]}")'
+        if t["t"] == "dec":
+            return f'rt::dec("{t["v"]}")'
+        if t["t"] == "date":
+            return f'rt::date("{t["v"]}")'
+        if t["t"] == "enum":
+            return f'rt::sym("{t["v"]}")'
+        return f'rt::text({json.dumps(t["v"], ensure_ascii=False)})'
+    if k == "bin":
+        return f'rt::{OPS[t["op"]]}(&{term(t["l"])}, &{term(t["r"])})?'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'rt::round(&{term(args[0])}, &{term(args[1])}, {json.dumps(args[2]["v"])})?'
+        return f'rt::{t["fn"]}(' + ", ".join(f"&{term(a)}" for a in args) + ')?'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["#![allow(unused_variables, unused_imports, clippy::all)]",
+         "use crate::rt::{self, Val, R};", ""]
+    L.append("pub const PREDS: &[&str] = &[")
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])},')
+    L.append("];")
+    L.append("")
+    L.append("/// Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("pub fn params(pred: &str) -> Option<&'static [&'static str]> {")
+    L.append("    match pred {")
+    for t in plan["tables"]:
+        L.append(f'        {json.dumps(t["pred"])} => Some(&[' + ", ".join(json.dumps(p) for p in t["params"]) + "]),")
+    L.append("        _ => None,")
+    L.append("    }")
+    L.append("}")
+    L.append("")
+    L.append("/// Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("pub fn consts(id: &str) -> Option<(&'static str, Val)> {")
+    L.append("    match id {")
+    for cid, c in plan["consts"].items():
+        L.append(f'        {json.dumps(cid)} => Some(({json.dumps(c["type"])}, {term(c["term"])})),')
+    L.append("        _ => None,")
+    L.append("    }")
+    L.append("}")
+    L.append("")
+    L.append("/// Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("pub const KEYS: &[(&str, &[&[usize]])] = &[")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'    ({json.dumps(t["pred"])}, &[' + ", ".join("&[" + ", ".join(f"{i}usize" for i in k) + "]" for k in t["keys"]) + "]),")
+    L.append("];")
+    L.append("pub const KEY_READERS: &[(&str, &[&str])] = &[")
+    for source, consumers in key_readers(plan).items():
+        L.append(f'    ({json.dumps(source)}, &[' + ", ".join(json.dumps(value) for value in consumers) + "]),")
+    L.append("];")
+    L.append("")
+    L.append("/// KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("pub fn key_conflicts(db: &rt::Db) -> usize {")
+    L.append("    let mut n = 0;")
+    L.append("    for (pred, keys) in KEYS {")
+    L.append("        for key in keys.iter() {")
+    L.append("            let mut groups: std::collections::BTreeMap<String, usize> = std::collections::BTreeMap::new();")
+    L.append("            for row in db.rows(pred) {")
+    L.append("                let proj: Vec<Val> = key.iter().map(|&i| row[i].clone()).collect();")
+    L.append("                *groups.entry(rt::key(&proj)).or_insert(0) += 1;")
+    L.append("            }")
+    L.append("            n += groups.values().filter(|&&c| c > 1).count();")
+    L.append("        }")
+    L.append("    }")
+    L.append("    n")
+    L.append("}")
+    L.append("pub fn key_conflict_predicates(db: &rt::Db) -> std::collections::BTreeSet<String> {")
+    L.append("    let mut out = std::collections::BTreeSet::new();")
+    L.append("    for (pred, keys) in KEYS { for key in keys.iter() { let mut groups: std::collections::BTreeMap<String, usize> = std::collections::BTreeMap::new(); for row in db.rows(pred) { let proj: Vec<Val> = key.iter().map(|&i| row[i].clone()).collect(); *groups.entry(rt::key(&proj)).or_insert(0) += 1; } if groups.values().any(|&c| c > 1) { out.insert((*pred).to_string()); } } }")
+    L.append("    out")
+    L.append("}")
+    L.append("")
+    L.append("/// Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("pub fn base(t: &str) -> Option<&'static str> {")
+    L.append("    match t {")
+    for sub, base in plan["bases"].items():
+        L.append(f'        {json.dumps(sub)} => Some({json.dumps(base)}),')
+    L.append("        _ => None,")
+    L.append("    }")
+    L.append("}")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'// {r["id"]}')
+        L.append(f'fn rule_{r["name"]}(db: &mut rt::Db) -> R<bool> {{')
+        L.append("    let mut grew = false;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'    if db.legal_time()?.as_str() < "{r["window"]["start"]}" {{ return Ok(false); }}')
+            if r["window"].get("end"):
+                L.append(f'    if db.legal_time()?.as_str() >= "{r["window"]["end"]}" {{ return Ok(false); }}')
+        ind = "    "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}let t{i} = db.rows({json.dumps(a["pred"])}).to_vec();')
+            L.append(f'{ind}for r{i} in &t{i} {{')
+            ind += "    "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}if !rt::cmp(&r{ai}[{aj}], "eq", &r{bi}[{bj}])? {{ continue; }}')
+        for f in r["filters"]:
+            L.append(f'{ind}if !rt::eq(&r{f["row"]}[{f["col"]}], &{term(f["term"])}) {{ continue; }}')
+        for g in r["guards"]:
+            L.append(f'{ind}if !rt::cmp(&{term(g["l"])}, "{g["op"]}", &{term(g["r"])})? {{ continue; }}')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if db.add({json.dumps(r["head"]["pred"])}, vec![{args}]) {{ grew = true; }}')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("    Ok(grew)")
+        L.append("}")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("pub fn saturate(db: &mut rt::Db) -> R<()> {")
+    L.append("    loop {")
+    L.append("        let mut grew = false;")
+    for n in names:
+        L.append(f"        if rule_{n}(db)? {{ grew = true; }}")
+    L.append("        if !grew { break; }")
+    L.append("    }")
+    L.append("    Ok(())")
+    L.append("}")
+    L.append("")
+    L.append("pub fn package_facts(db: &mut rt::Db) -> R<()> {")
+    for f in plan["facts"]:
+        L.append(f'    db.add({json.dumps(f["pred"])}, vec![' + ", ".join(term(a) for a in f["args"]) + "]);")
+    L.append("    Ok(())")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "rs"
+MODEL = "src/model.rs"
+MAINS = {"runner": "runner.rs", "cert": "cert.rs"}
+CARGO = '''[package]
+name = "{name}"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "{name}"
+path = "src/main.rs"
+
+[dependencies]
+num-bigint = "0.4"
+num-integer = "0.1"
+num-traits = "0.2"
+serde_json = { version = "1", features = ["arbitrary_precision"] }
+
+[profile.dev]
+opt-level = 1
+'''
+
+
+def available():
+    cargo = shutil.which("cargo")
+    return (True, cargo) if cargo else (False, "нет cargo в PATH")
+
+
+def crate_name(proj) -> str:
+    """Имя крейта и бинаря — по каталогу вектора: общий `--target-dir` иначе
+    складывал бы все модели в один бинарь и запускал последнюю собранную."""
+    import re as _re
+    return "law_" + _re.sub(r"[^a-z0-9]", "_", Path(proj).parent.name.lower())
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    (proj / "src").mkdir(parents=True, exist_ok=True)
+    out = []
+    shutil.copyfile(HERE / "runtime.rs", proj / "src" / "rt.rs")
+    shutil.copyfile(HERE / MAINS[main], proj / "src" / "main.rs")
+    (proj / "Cargo.toml").write_text(CARGO.replace("{name}", crate_name(proj)), encoding="utf-8")
+    out += [proj / "src" / "rt.rs", proj / "src" / "main.rs", proj / "Cargo.toml"]
+    return out
+
+
+def build(proj):
+    """Общий `--target-dir` на все проекты рабочего каталога: зависимости
+    компилируются один раз, модели — по отдельности."""
+    proj = Path(proj)
+    target = proj.parents[1] / "rust-target"
+    return ["cargo", "build", "-q", "--offline", "--target-dir", str(target)], str(proj)
+
+
+def run(proj, main: str):
+    proj = Path(proj)
+    return [str(proj.parents[1] / "rust-target" / "debug" / crate_name(proj))], None
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(HERE.parents[1]))
+    import plan as P
+    ir = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    Path(sys.argv[2]).write_text(emit(P.build_plan(ir)), encoding="utf-8")

arxo_codegen/targets/rs/prefetch.rs

@@ -0,0 +1 @@
+//! Empty target for the locked CI dependency-prefetch manifest.

arxo_codegen/targets/rs/runner.rs

@@ -0,0 +1,181 @@
+//! Раннер Rust-бэкенда: тот же вход и тот же ответ, что у runner.py.
+//!
+//! Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+//! среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+mod model;
+mod rt;
+
+use rt::{Refused, Val, R};
+use serde_json::{json, Value};
+
+fn lit_text(v: &Value) -> String {
+    match v {
+        Value::String(s) => s.clone(),
+        Value::Number(n) => n.to_string(),
+        other => other.to_string(),
+    }
+}
+
+fn arg(a: &Value) -> R<Val> {
+    let kind = a["kind"].as_str().unwrap_or("");
+    if kind == "entity_ref" {
+        return Ok(rt::text(a["id"].as_str().unwrap_or("")));
+    }
+    if kind == "const_ref" {
+        // §54: разыменование предшествует исполнению; член перечисления §38 либо
+        // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+        let id = a["id"].as_str().unwrap_or("");
+        return Ok(match model::consts(id) {
+            Some((_, v)) => v,
+            None => rt::sym(id),
+        });
+    }
+    if kind != "value" {
+        return Err(Refused(format!("аргумент вне среза раннера: {kind}")));
+    }
+    let t = a["type"]["name"].as_str().unwrap_or("");
+    match t {
+        "urn:law:std#Money" => Ok(rt::money(&lit_text(&a["value"]), a["currency"].as_str().unwrap_or(""))),
+        "urn:law:std#Decimal" | "urn:law:std#Integer" => Ok(rt::dec(&lit_text(&a["value"]))),
+        "urn:law:std#Text" => Ok(rt::text(&lit_text(&a["value"]))),
+        "urn:law:std#Date" => Ok(rt::date(&lit_text(&a["value"]))),
+        _ => Err(Refused(format!("аргумент вне среза раннера: {t}"))),
+    }
+}
+
+/// Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+/// константы; entity_ref типа не несёт (как у оракула).
+fn arg_type(a: &Value) -> Option<String> {
+    match a["kind"].as_str() {
+        Some("value") => a["type"]["name"].as_str().map(str::to_string),
+        Some("const_ref") => model::consts(a["id"].as_str().unwrap_or("")).map(|(t, _)| t.to_string()),
+        _ => None,
+    }
+}
+
+/// Совпадение типа с наследованием сущностей вверх от фактического.
+fn conforms(actual: &str, expected: &str) -> bool {
+    let mut seen = std::collections::BTreeSet::new();
+    let mut cur = Some(actual.to_string());
+    while let Some(c) = cur {
+        if c == expected {
+            return true;
+        }
+        if !seen.insert(c.clone()) {
+            break;
+        }
+        cur = model::base(&c).map(str::to_string);
+    }
+    false
+}
+
+fn args_of(lit: &Value) -> Vec<Value> {
+    lit["args"].as_array().cloned().unwrap_or_default()
+}
+
+/// Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+fn well_typed(lit: &Value, issues: &mut Vec<String>) -> bool {
+    let Some(params) = model::params(lit["predicate"].as_str().unwrap_or("")) else { return true };
+    let args = args_of(lit);
+    if args.len() != params.len() {
+        issues.push("TYPE_ERROR".into());
+        return false;
+    }
+    for (expected, a) in params.iter().zip(args.iter()) {
+        if let Some(actual) = arg_type(a) {
+            if !conforms(&actual, expected) {
+                issues.push("TYPE_ERROR".into());
+                return false;
+            }
+        }
+    }
+    true
+}
+
+/// Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+/// атома не находит — NEITHER без issue.
+fn query_typed(lit: &Value) -> bool {
+    let Some(params) = model::params(lit["predicate"].as_str().unwrap_or("")) else { return false };
+    let args = args_of(lit);
+    if args.len() != params.len() {
+        return false;
+    }
+    params.iter().zip(args.iter()).all(|(expected, a)| match arg_type(a) {
+        Some(actual) => conforms(&actual, expected),
+        None => true,
+    })
+}
+
+fn key_conflict_blocks(db: &rt::Db, predicate: &str) -> bool {
+    let mut tainted = model::key_conflict_predicates(db);
+    let mut waiting: Vec<String> = tainted.iter().cloned().collect();
+    while let Some(source) = waiting.pop() {
+        for (reader, consumers) in model::KEY_READERS {
+            if *reader == source {
+                for consumer in *consumers {
+                    if tainted.insert((*consumer).to_string()) { waiting.push((*consumer).to_string()); }
+                }
+            }
+        }
+    }
+    tainted.contains(predicate)
+}
+
+fn run(case: Value, query: Value) -> R<Value> {
+    let mut db = rt::Db::new(model::PREDS);
+    let mut issues: Vec<String> = Vec::new();
+    db.set_legal_time(case["context"]["legalTime"].as_str().unwrap_or(""));
+    model::package_facts(&mut db)?;
+    for a in case["assertions"].as_array().cloned().unwrap_or_default() {
+        let lit = &a["literal"];
+        if lit["polarity"].as_str() != Some("positive") {
+            return Err(Refused("§113: отрицательный факт вне L0-среза".into()));
+        }
+        if !well_typed(lit, &mut issues) {
+            continue;
+        }
+        let pred = lit["predicate"].as_str().unwrap_or("");
+        if !db.has(pred) {
+            continue;
+        }
+        let row = args_of(lit).iter().map(arg).collect::<R<Vec<Val>>>()?;
+        db.add(pred, row);
+    }
+    model::saturate(&mut db)?;
+    for _ in 0..model::key_conflicts(&db) {
+        issues.push("KEY_CONFLICT".into());
+    }
+    if query["kind"].as_str() != Some("truth") {
+        return Err(Refused(format!("вид запроса вне среза раннера: {}", lit_text(&query["kind"]))));
+    }
+    let lit = &query["literal"];
+    let mut hit = false;
+    if query_typed(lit) {
+        let want = args_of(lit).iter().map(arg).collect::<R<Vec<Val>>>()?;
+        let pred = lit["predicate"].as_str().unwrap_or("");
+        hit = db
+            .rows(pred)
+            .iter()
+            .any(|r| r.len() == want.len() && r.iter().zip(want.iter()).all(|(v, w)| rt::eq(v, w)));
+    }
+    // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+    Ok(json!({
+        "queryId": query["queryId"],
+        "truthStatus": if hit { "TRUE_ONLY" } else { "NEITHER" },
+        "evaluationStatus": if key_conflict_blocks(&db, lit["predicate"].as_str().unwrap_or("")) { "NON_EXECUTABLE" } else { "COMPUTED" },
+        "issues": issues,
+    }))
+}
+
+fn main() {
+    let argv: Vec<String> = std::env::args().collect();
+    let case: Value = serde_json::from_str(&std::fs::read_to_string(&argv[1]).expect("case")).expect("case json");
+    let query: Value = serde_json::from_str(&std::fs::read_to_string(&argv[2]).expect("query")).expect("query json");
+    match run(case, query) {
+        Ok(out) => println!("{}", serde_json::to_string(&out).unwrap()),
+        Err(Refused(msg)) => {
+            println!("{}", serde_json::to_string(&json!({ "refused": msg })).unwrap());
+            std::process::exit(3);
+        }
+    }
+}