arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/swift/cert.swift

@@ -0,0 +1,105 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+// В проекте файл лежит как main.swift: только там Swift допускает код верхнего уровня.
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+enum Arg {
+    case s(String)
+    case v(V)
+    case row([V])
+}
+
+func lit(_ x: J) -> Arg {
+    if let s = x.string { return .s(s) }
+    if let d = x["dec"]?.string { return .v(RT.dec(d)) }
+    if let m = x["money"]?.string { return .v(RT.money(m, x["cur"]?.string ?? "")) }
+    if let t = x["text"]?.string { return .v(.text(t)) }
+    if let d = x["date"]?.string { return .v(RT.date(d)) }
+    if let s = x["sym"]?.string { return .v(RT.sym(s)) }
+    if let row = x["row"] {
+        return .row(row.array.map { cell -> V in
+            guard case let .v(v) = lit(cell) else { fatalError("ячейка фикстуры") }
+            return v
+        })
+    }
+    fatalError("литерал фикстуры")
+}
+
+// Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+func digits(_ u: BigI, _ s: Int) -> String {
+    var body = u.magnitude.description
+    if body.count < s + 1 { body = String(repeating: "0", count: s + 1 - body.count) + body }
+    if s > 0 { body = String(body.dropLast(s)) + "." + String(body.suffix(s)) }
+    return (u.neg ? "-" : "") + body
+}
+
+func render(_ v: V) -> String {
+    switch v {
+    case let .text(t): return jstr(t)
+    case let .money(u, s, cur): return jstr(digits(u, s) + " " + cur)
+    case let .dec(u, s): return jstr(digits(u, s))
+    case let .date(d): return jstr(d)
+    case let .sym(id): return jstr(id)
+    }
+}
+
+func val(_ a: Arg) -> V {
+    if case let .v(v) = a { return v }
+    if case let .s(s) = a { return .text(s) }
+    fatalError("ожидалось значение")
+}
+
+func str(_ a: Arg) -> String {
+    if case let .s(s) = a { return s }
+    fatalError("ожидалась строка")
+}
+
+func rowOf(_ a: Arg) -> [V] {
+    if case let .row(r) = a { return r }
+    fatalError("ожидалась строка таблицы")
+}
+
+func run(_ op: String, _ a: [Arg]) throws -> String {
+    switch op {
+    case "dec": return render(RT.dec(str(a[0])))
+    case "money": return render(RT.money(str(a[0]), str(a[1])))
+    case "date": return render(RT.date(str(a[0])))
+    case "sym": return render(RT.sym(str(a[0])))
+    case "mul": return render(try RT.mul(val(a[0]), val(a[1])))
+    case "add": return render(try RT.add(val(a[0]), val(a[1])))
+    case "sub": return render(try RT.sub(val(a[0]), val(a[1])))
+    case "div": return render(try RT.div(val(a[0]), val(a[1])))
+    case "mod": return render(try RT.mod(val(a[0]), val(a[1])))
+    case "min": return render(try RT.min(val(a[0]), val(a[1])))
+    case "max": return render(try RT.max(val(a[0]), val(a[1])))
+    case "abs": return render(try RT.abs(val(a[0])))
+    case "pow": return render(try RT.pow(val(a[0]), val(a[1])))
+    case "round": return render(try RT.round(val(a[0]), val(a[1]), str(a[2])))
+    case "cmp": return try RT.cmp(val(a[0]), str(a[1]), val(a[2])) ? "true" : "false"
+    case "eq": return RT.eq(val(a[0]), val(a[1])) ? "true" : "false"
+    case "keyEq": return RT.key(rowOf(a[0])) == RT.key(rowOf(a[1])) ? "true" : "false"
+    case "legalTime": return jstr(try RT.legalTime())
+    case "setLegalTime":
+        RT.setLegalTime(str(a[0]))
+        return "null"
+    default: fatalError("неизвестная операция фикстуры: \(op)")
+    }
+}
+
+let fixture = readJSON(CommandLine.arguments[1])
+var out: [String] = []
+for c in fixture["cases"]?.array ?? [] {
+    let args = (c["args"]?.array ?? []).map(lit)
+    var got: String
+    do {
+        got = try run(c["op"]?.string ?? "", args)
+    } catch let e as Refused {
+        got = "{\"refused\":" + jstr(e.message) + "}"
+    }
+    out.append("{\"id\":" + jstr(c["id"]?.string ?? "") + ",\"got\":" + got + "}")
+}
+print("[" + out.joined(separator: ",") + "]")

arxo_codegen/targets/swift/emit.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Эмиттер Swift. Тот же план и тот же контракт рантайма; модель — `enum Model`
+со статическими таблицами, отказ — `throw Refused`, поэтому каждое выражение с
+вызовом рантайма стоит под `try`."""
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def ss(s: str) -> str:
+    """Строковый литерал Swift: экраны JSON вида `\\uXXXX` и `\\b` Swift не знает
+    (у него `\\u{…}`), а `\\(` — интерполяция; экранируются кавычка, экран и
+    управляющие символы."""
+    return '"' + "".join("\\\\" if c == "\\" else '\\"' if c == '"' else
+                         f"\\u{{{ord(c):x}}}" if ord(c) < 0x20 or ord(c) == 0x7F else c
+                         for c in s) + '"'
+
+
+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 term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money({ss(t["v"])}, {ss(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT.dec({ss(t["v"])})'
+        if t["t"] == "date":
+            return f'RT.date({ss(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT.sym({ss(t["v"])})'
+        return f'V.text({ss(t["v"])})'
+    if k == "bin":
+        return f'RT.{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])}, {ss(args[2]["v"])})'
+        return f'RT.{t["fn"]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["enum Model {", "    static var TABLES: [String: [[V]]] = ["]
+    for t in plan["tables"]:
+        L.append(f'        {ss(t["pred"])}: [],')
+    if not plan["tables"]:
+        L.append("        :")
+    L.append("    ]")
+    L.append("    // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("    static let PARAMS: [String: [String]] = [")
+    for t in plan["tables"]:
+        L.append(f'        {ss(t["pred"])}: [' + ", ".join(ss(p) for p in t["params"]) + "],")
+    if not plan["tables"]:
+        L.append("        :")
+    L.append("    ]")
+    L.append("    // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("    static func consts() throws -> [String: (String, V)] {")
+    L.append("        var c: [String: (String, V)] = [:]")
+    for cid, c in plan["consts"].items():
+        L.append(f'        c[{ss(cid)}] = ({ss(c["type"])}, try {term(c["term"])})')
+    L.append("        return c")
+    L.append("    }")
+    L.append("    // Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("    static let BASES: [String: String] = [")
+    for sub, base in plan["bases"].items():
+        L.append(f"        {ss(sub)}: {ss(base)},")
+    if not plan["bases"]:
+        L.append("        :")
+    L.append("    ]")
+    L.append("    // Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("    static let KEYS: [(String, [[Int]])] = [")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'        ({ss(t["pred"])}, {json.dumps(t["keys"])}),')
+    L.append("    ]")
+    readers = key_readers(plan)
+    L.append("    static let KEY_READERS: [String: [String]] = [")
+    for source, consumers in readers.items():
+        L.append(f'        {ss(source)}: [' + ", ".join(ss(value) for value in consumers) + "],")
+    if not readers:
+        L.append("        :")
+    L.append("    ]")
+    L.append("    static var seen: [String: Set<String>] = [:]")
+    L.append("")
+    L.append("    static func addRow(_ urn: String, _ row: [V]) -> Bool {")
+    L.append("        if !seen[urn, default: []].insert(RT.key(row)).inserted { return false }")
+    L.append("        TABLES[urn]!.append(row)")
+    L.append("        return true")
+    L.append("    }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'    // {r["id"]}')
+        L.append(f'    static func rule_{r["name"]}() throws -> Bool {{')
+        L.append("        var grew = false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'        if try RT.legalTime() < {ss(r["window"]["start"])} {{ return false }}')
+            if r["window"].get("end"):
+                L.append(f'        if try RT.legalTime() >= {ss(r["window"]["end"])} {{ return false }}')
+        ind = "        "
+        for i, a in enumerate(r["atoms"]):
+            # Массив Swift — значение: цикл идёт по снимку таблицы на входе.
+            L.append(f'{ind}for r{i} in TABLES[{ss(a["pred"])}]! {{')
+            ind += "    "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}if !(try 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 !(try 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 try addRow({ss(r["head"]["pred"])}, [{args}]) {{ grew = true }}')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("        return grew")
+        L.append("    }")
+        L.append("")
+    L.append("    static func saturate() throws {")
+    L.append("        var grew = true")
+    L.append("        while grew {")
+    L.append("            grew = false")
+    for r in plan["rules"]:
+        L.append(f'            if try rule_{r["name"]}() {{ grew = true }}')
+    L.append("        }")
+    L.append("    }")
+    L.append("")
+    L.append("    static func register(_ urn: String, _ row: [V]) -> Bool { addRow(urn, row) }")
+    L.append("")
+    L.append("    // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("    static func keyConflicts() -> Int {")
+    L.append("        var n = 0")
+    L.append("        for (urn, keys) in KEYS {")
+    L.append("            for key in keys {")
+    L.append("                var groups: [String: Int] = [:]")
+    L.append("                for row in TABLES[urn]! { groups[RT.key(key.map { row[$0] }), default: 0] += 1 }")
+    L.append("                n += groups.values.filter { $0 > 1 }.count")
+    L.append("            }")
+    L.append("        }")
+    L.append("        return n")
+    L.append("    }")
+    L.append("    static func keyConflictPredicates() -> Set<String> {")
+    L.append("        var out = Set<String>()")
+    L.append("        for (urn, keys) in KEYS { for key in keys { var groups: [String: Int] = [:]; for row in TABLES[urn]! { groups[RT.key(key.map { row[$0] }), default: 0] += 1 }; if groups.values.contains(where: { $0 > 1 }) { out.insert(urn) } } }")
+    L.append("        return out")
+    L.append("    }")
+    L.append("")
+    L.append("    // Собственные факты пакета: раннер кладёт их до фактов дела.")
+    L.append("    static func packageFacts() throws {")
+    for f in plan["facts"]:
+        L.append(f'        _ = try addRow({ss(f["pred"])}, [' + ", ".join(term(a) for a in f["args"]) + "])")
+    L.append("    }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "swift"
+MODEL = "model.swift"
+MAINS = {"runner": "runner.swift", "cert": "cert.swift"}
+BINS = {"runner": "runner", "cert": "cert"}
+FLAGS = ["-Onone", "-swift-version", "5"]
+# Одна сборка проекта; main.swift — раннер либо харнесс, модель есть только у раннера.
+COMPILE = ("if [ -f model.swift ]; then swiftc {flags} runtime.swift json.swift model.swift main.swift -o runner; "
+           "else swiftc {flags} runtime.swift json.swift main.swift -o cert; fi").format(flags=" ".join(FLAGS))
+
+
+def available():
+    swiftc = shutil.which("swiftc")
+    return (True, swiftc) if swiftc else (False, "нет swiftc в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.swift", "json.swift"):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    shutil.copyfile(HERE / MAINS[main], proj / "main.swift")
+    out.append(proj / "main.swift")
+    return out
+
+
+def build(proj):
+    return ["sh", "-c", COMPILE], str(proj)
+
+
+def build_many(dirs, out):
+    """Сборка всех проектов ворот параллельно: swiftc на проект — секунды, а
+    проектов больше сорока. Одного бинаря на все модели не выходит: у каждой
+    модели тот же `enum Model`."""
+    jobs = str(max(2, min(8, (os.cpu_count() or 4) // 2)))
+    script = f"printf '%s\\0' \"$@\" | xargs -0 -n 1 -P {jobs} sh -c 'cd \"$1\" && {COMPILE}' sh"
+    return ["sh", "-c", script, "sh", *[str(d) for d in dirs]], None
+
+
+def run(proj, main: str):
+    return [str(Path(proj) / BINS[main])], 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/swift/json.swift

@@ -0,0 +1,208 @@
+// Разбор и печать JSON без Foundation: `JSONSerialization` отдаёт числа как
+// NSNumber (двоичная плавающая точка у дробных, потеря цифр у длинных целых),
+// поэтому число здесь хранится исходной записью.
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+indirect enum J {
+    case null
+    case bool(Bool)
+    case num(String)
+    case str(String)
+    case arr([J])
+    case obj([String: J])
+
+    subscript(_ key: String) -> J? {
+        if case let .obj(o) = self { return o[key] }
+        return nil
+    }
+
+    var array: [J] {
+        if case let .arr(a) = self { return a }
+        return []
+    }
+
+    var string: String? {
+        if case let .str(s) = self { return s }
+        return nil
+    }
+
+    /// Текст значения: строка как есть, число — его запись, иначе пусто.
+    var text: String {
+        switch self {
+        case let .str(s): return s
+        case let .num(t): return t
+        case let .bool(b): return b ? "true" : "false"
+        default: return ""
+        }
+    }
+}
+
+struct JParser {
+    let b: [UInt8]
+    var i = 0
+
+    init(_ bytes: [UInt8]) { b = bytes }
+
+    func fail(_ what: String) -> Never { fatalError("JSON: \(what) в позиции \(i)") }
+
+    mutating func ws() {
+        while i < b.count, b[i] == 0x20 || b[i] == 0x0A || b[i] == 0x0D || b[i] == 0x09 { i += 1 }
+    }
+
+    mutating func lit(_ word: String) -> Bool {
+        let w = Array(word.utf8)
+        if i + w.count <= b.count && Array(b[i..<(i + w.count)]) == w {
+            i += w.count
+            return true
+        }
+        return false
+    }
+
+    mutating func value() -> J {
+        ws()
+        guard i < b.count else { fail("конец входа") }
+        switch b[i] {
+        case UInt8(ascii: "{"):
+            i += 1
+            var o: [String: J] = [:]
+            ws()
+            if b[i] == UInt8(ascii: "}") {
+                i += 1
+                return .obj(o)
+            }
+            while true {
+                ws()
+                guard b[i] == UInt8(ascii: "\"") else { fail("ожидался ключ") }
+                let k = string()
+                ws()
+                guard b[i] == UInt8(ascii: ":") else { fail("ожидалось ':'") }
+                i += 1
+                o[k] = value()
+                ws()
+                if b[i] == UInt8(ascii: "}") {
+                    i += 1
+                    return .obj(o)
+                }
+                guard b[i] == UInt8(ascii: ",") else { fail("ожидалось ',' или '}'") }
+                i += 1
+            }
+        case UInt8(ascii: "["):
+            i += 1
+            var a: [J] = []
+            ws()
+            if b[i] == UInt8(ascii: "]") {
+                i += 1
+                return .arr(a)
+            }
+            while true {
+                a.append(value())
+                ws()
+                if b[i] == UInt8(ascii: "]") {
+                    i += 1
+                    return .arr(a)
+                }
+                guard b[i] == UInt8(ascii: ",") else { fail("ожидалось ',' или ']'") }
+                i += 1
+            }
+        case UInt8(ascii: "\""):
+            return .str(string())
+        default:
+            if lit("true") { return .bool(true) }
+            if lit("false") { return .bool(false) }
+            if lit("null") { return .null }
+            let start = i
+            while i < b.count, "+-.eE0123456789".utf8.contains(b[i]) { i += 1 }
+            if start == i { fail("неизвестное значение") }
+            return .num(String(decoding: b[start..<i], as: UTF8.self))
+        }
+    }
+
+    mutating func hex4() -> UInt32 {
+        guard i + 4 <= b.count, let v = UInt32(String(decoding: b[i..<(i + 4)], as: UTF8.self), radix: 16) else {
+            fail("плохой \\u")
+        }
+        i += 4
+        return v
+    }
+
+    mutating func string() -> String {
+        i += 1
+        var out: [UInt8] = []
+        while true {
+            guard i < b.count else { fail("строка не закрыта") }
+            let c = b[i]
+            if c == UInt8(ascii: "\"") {
+                i += 1
+                return String(decoding: out, as: UTF8.self)
+            }
+            if c != UInt8(ascii: "\\") {
+                out.append(c)
+                i += 1
+                continue
+            }
+            let e = b[i + 1]
+            i += 2
+            switch e {
+            case UInt8(ascii: "\""), UInt8(ascii: "\\"), UInt8(ascii: "/"): out.append(e)
+            case UInt8(ascii: "b"): out.append(0x08)
+            case UInt8(ascii: "f"): out.append(0x0C)
+            case UInt8(ascii: "n"): out.append(0x0A)
+            case UInt8(ascii: "r"): out.append(0x0D)
+            case UInt8(ascii: "t"): out.append(0x09)
+            case UInt8(ascii: "u"):
+                var cp = hex4()
+                if cp >= 0xD800 && cp <= 0xDBFF && i + 1 < b.count && b[i] == UInt8(ascii: "\\") && b[i + 1] == UInt8(ascii: "u") {
+                    i += 2
+                    let lo = hex4()
+                    cp = 0x10000 + ((cp - 0xD800) << 10) + (lo &- 0xDC00)
+                }
+                out.append(contentsOf: String(Unicode.Scalar(cp) ?? "\u{FFFD}").utf8)
+            default: fail("плохой экран")
+            }
+        }
+    }
+}
+
+func readJSON(_ path: String) -> J {
+    guard let f = fopen(path, "rb") else { fatalError("не открыть \(path)") }
+    defer { fclose(f) }
+    var bytes: [UInt8] = []
+    var buf = [UInt8](repeating: 0, count: 65536)
+    while true {
+        let n = fread(&buf, 1, buf.count, f)
+        if n <= 0 { break }
+        bytes.append(contentsOf: buf[0..<n])
+    }
+    var p = JParser(bytes)
+    let v = p.value()
+    p.ws()
+    if p.i != bytes.count { p.fail("лишнее после значения") }
+    return v
+}
+
+/// Строка JSON: символы как есть (stdout получает UTF-8), экранируются
+/// кавычка, экран и управляющие символы.
+func jstr(_ s: String) -> String {
+    var out = "\""
+    for ch in s.unicodeScalars {
+        switch ch {
+        case "\"": out += "\\\""
+        case "\\": out += "\\\\"
+        case "\n": out += "\\n"
+        case "\r": out += "\\r"
+        case "\t": out += "\\t"
+        default:
+            if ch.value < 0x20 {
+                let h = String(ch.value, radix: 16)
+                out += "\\u" + String(repeating: "0", count: 4 - h.count) + h
+            } else {
+                out.unicodeScalars.append(ch)
+            }
+        }
+    }
+    return out + "\""
+}

arxo_codegen/targets/swift/runner.swift

@@ -0,0 +1,133 @@
+// Раннер Swift-бэкенда: тот же вход и тот же ответ, что у runner.rb.
+// В проекте файл лежит как main.swift: только там Swift допускает код верхнего уровня.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+// целями; любая другая ошибка — крах, который ворота валят.
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+var ISSUES: [String] = []
+var CONSTS: [String: (String, V)] = [:]
+
+func arg(_ a: J) throws -> V {
+    let kind = a["kind"]?.text ?? ""
+    if kind == "entity_ref" { return .text(a["id"]?.text ?? "") }
+    if kind == "const_ref" {
+        // §54: разыменование предшествует исполнению; член перечисления §38 либо
+        // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+        let id = a["id"]?.text ?? ""
+        if let c = CONSTS[id] { return c.1 }
+        return RT.sym(id)
+    }
+    if kind != "value" { throw Refused("аргумент вне среза раннера: \(kind)") }
+    let t = a["type"]?["name"]?.text ?? ""
+    let v = a["value"]?.text ?? ""
+    switch t {
+    case "urn:law:std#Money": return RT.money(v, a["currency"]?.text ?? "")
+    case "urn:law:std#Decimal", "urn:law:std#Integer": return RT.dec(v)
+    case "urn:law:std#Text": return .text(v)
+    case "urn:law:std#Date": return RT.date(v)
+    default: throw Refused("аргумент вне среза раннера: \(t)")
+    }
+}
+
+// Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+// константы; entity_ref типа не несёт (как у оракула).
+func argType(_ a: J) -> String? {
+    switch a["kind"]?.text {
+    case "value": return a["type"]?["name"]?.string
+    case "const_ref": return CONSTS[a["id"]?.text ?? ""]?.0
+    default: return nil
+    }
+}
+
+// Совпадение типа с наследованием сущностей вверх от фактического.
+func conforms(_ actual: String, _ expected: String) -> Bool {
+    var seen = Set<String>()
+    var cur: String? = actual
+    while let c = cur, !seen.contains(c) {
+        if c == expected { return true }
+        seen.insert(c)
+        cur = Model.BASES[c]
+    }
+    return false
+}
+
+// Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+func wellTyped(_ lit: J) -> Bool {
+    guard let params = Model.PARAMS[lit["predicate"]?.text ?? ""] else { return true }
+    let args = lit["args"]?.array ?? []
+    if args.count != params.count {
+        ISSUES.append("TYPE_ERROR")
+        return false
+    }
+    for (expected, a) in zip(params, args) {
+        if let actual = argType(a), !conforms(actual, expected) {
+            ISSUES.append("TYPE_ERROR")
+            return false
+        }
+    }
+    return true
+}
+
+// Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+// атома не находит — NEITHER без issue.
+func queryTyped(_ lit: J) -> Bool {
+    guard let params = Model.PARAMS[lit["predicate"]?.text ?? ""] else { return false }
+    let args = lit["args"]?.array ?? []
+    if args.count != params.count { return false }
+    return zip(params, args).allSatisfy { expected, a in argType(a).map { conforms($0, expected) } ?? true }
+}
+
+func keyConflictBlocks(_ predicate: String) -> Bool {
+    var tainted = Model.keyConflictPredicates()
+    var waiting = Array(tainted)
+    while let source = waiting.popLast() {
+        for consumer in Model.KEY_READERS[source] ?? [] where tainted.insert(consumer).inserted { waiting.append(consumer) }
+    }
+    return tainted.contains(predicate)
+}
+
+func runMain() throws {
+    let kase = readJSON(CommandLine.arguments[1])
+    let query = readJSON(CommandLine.arguments[2])
+    RT.setLegalTime(kase["context"]?["legalTime"]?.text ?? "")
+    CONSTS = try Model.consts()
+    try Model.packageFacts()
+    for a in kase["assertions"]?.array ?? [] {
+        guard let lit = a["literal"] else { continue }
+        if lit["polarity"]?.text != "positive" { throw Refused("§113: отрицательный факт вне L0-среза") }
+        if !wellTyped(lit) { continue }
+        let pred = lit["predicate"]?.text ?? ""
+        if Model.PARAMS[pred] == nil { continue }
+        _ = Model.register(pred, try (lit["args"]?.array ?? []).map(arg))
+    }
+    try Model.saturate()
+    for _ in 0..<Model.keyConflicts() { ISSUES.append("KEY_CONFLICT") }
+    let kind = query["kind"]?.text ?? ""
+    if kind != "truth" { throw Refused("вид запроса вне среза раннера: \(kind)") }
+    var hit = false
+    if let ql = query["literal"], queryTyped(ql) {
+        let want = try (ql["args"]?.array ?? []).map(arg)
+        let rows = Model.TABLES[ql["predicate"]?.text ?? ""] ?? []
+        hit = rows.contains { r in r.count == want.count && zip(r, want).allSatisfy { RT.eq($0, $1) } }
+    }
+    // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+    print("{\"queryId\":" + jstr(query["queryId"]?.text ?? "") +
+          ",\"truthStatus\":" + jstr(hit ? "TRUE_ONLY" : "NEITHER") +
+          ",\"evaluationStatus\":" + jstr(keyConflictBlocks(query["literal"]?["predicate"]?.text ?? "") ? "NON_EXECUTABLE" : "COMPUTED") + ",\"issues\":[" + ISSUES.map(jstr).joined(separator: ",") + "]}")
+}
+
+do {
+    try runMain()
+} catch let e as Refused {
+    print("{\"refused\":" + jstr(e.message) + "}")
+    exit(3)
+} catch {
+    fputs("error: \(error)\n", stderr)
+    exit(1)
+}