arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/kt/Runtime.kt

@@ -0,0 +1,196 @@
+// Рантайм L0 для Kotlin (JVM). Тот же контракт, что у runtime.py: точная
+// десятичная арифметика §58 на BigInteger, деньги с валютой, названный режим
+// округления, календарный день, член перечисления. Отказ — исключение Refused;
+// любое другое исключение — крах.
+import java.math.BigInteger
+
+class Refused(m: String) : RuntimeException(m)
+
+open class Dec(val u: BigInteger, val s: Int)
+class Money(u: BigInteger, s: Int, val cur: String) : Dec(u, s)
+// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD.
+class Date(val v: String)
+// Член перечисления §38 либо ссылка const_ref без объявления.
+class Sym(val id: String)
+
+object RT {
+    private fun p10(n: Int): BigInteger = BigInteger.TEN.pow(n)
+
+    fun dec(lit: String): Dec {
+        val dot = lit.indexOf('.')
+        val i = if (dot < 0) lit else lit.substring(0, dot)
+        val f = if (dot < 0) "" else lit.substring(dot + 1)
+        val neg = i.startsWith("-")
+        val u = BigInteger((if (neg) i.substring(1) else i) + f)
+        return Dec(if (neg) u.negate() else u, f.length)
+    }
+    fun money(lit: String, cur: String): Money { val d = dec(lit); return Money(d.u, d.s, cur) }
+    fun date(lit: String) = Date(lit)
+    fun sym(id: String) = Sym(id)
+
+    // --- виды ---------------------------------------------------------------
+    // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+    private fun same(a: Any?, b: Any?, op: String) {
+        if (a !is Dec || b !is Dec || (a is Money) != (b is Money)) throw Refused("§58: виды операндов не совпадают: $op")
+        if (a is Money && b is Money && a.cur != b.cur) throw Refused("§58: разные валюты: $op")
+    }
+    private fun pair(a: Dec, b: Dec): Triple<BigInteger, BigInteger, Int> {
+        val s = maxOf(a.s, b.s)
+        return Triple(a.u * p10(s - a.s), b.u * p10(s - b.s), s)
+    }
+    private fun mk(u: BigInteger, s: Int, like: Any?): Dec = if (like is Money) Money(u, s, like.cur) else Dec(u, s)
+    // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+    private fun integral(v: Any?): BigInteger? {
+        if (v !is Dec || v is Money) return null
+        val qr = v.u.divideAndRemainder(p10(v.s))
+        return if (qr[1].signum() == 0) qr[0] else null
+    }
+
+    // --- арифметика §58 -----------------------------------------------------
+    fun add(a: Any?, b: Any?): Dec { same(a, b, "add"); val (x, y, s) = pair(a as Dec, b as Dec); return mk(x + y, s, a) }
+    fun sub(a: Any?, b: Any?): Dec { same(a, b, "sub"); val (x, y, s) = pair(a as Dec, b as Dec); return mk(x - y, s, a) }
+
+    // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+    // сумма масштабов. Два размерных не перемножаются.
+    fun mul(a: Any?, b: Any?): Dec {
+        if (a !is Dec || b !is Dec) throw Refused("§58: виды операндов не совпадают: mul")
+        if (a is Money && b is Money) throw Refused("§58: произведение двух размерных величин не определено")
+        return mk(a.u * b.u, a.s + b.s, if (a is Money) a else b)
+    }
+
+    // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе null.
+    private fun exact(num0: BigInteger, den0: BigInteger): Pair<BigInteger, Int>? {
+        var g = num0.gcd(den0)
+        if (g.signum() == 0) g = BigInteger.ONE
+        var num = num0 / g
+        var den = den0 / g
+        if (den.signum() < 0) { num = num.negate(); den = den.negate() }
+        val two = BigInteger.TWO; val five = BigInteger.valueOf(5)
+        var twos = 0; var fives = 0
+        while (den.mod(two).signum() == 0) { den /= two; twos++ }
+        while (den.mod(five).signum() == 0) { den /= five; fives++ }
+        if (den != BigInteger.ONE) return null
+        val k = maxOf(twos, fives)
+        return Pair(num * two.pow(k - twos) * five.pow(k - fives), k)
+    }
+
+    // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+    // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+    fun div(a: Any?, b: Any?): Dec {
+        if (a !is Dec || b !is Dec) throw Refused("§58: деление вне таблицы делимых")
+        if (b.u.signum() == 0) throw Refused("деление на ноль — evaluation error (§58)")
+        var like: Money? = null
+        if (a is Money && b is Money) {
+            if (a.cur != b.cur) throw Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+        } else if (a is Money) like = a
+        else if (b is Money) throw Refused("§58: деление вне таблицы делимых")
+        val q = exact(a.u * p10(b.s), b.u * p10(a.s))
+            ?: throw Refused(if (like != null) "INEXACT_DIVISION: округление только явной политикой (§50/§18)" else "§58: частное не 10-гладкое — Rational вне среза")
+        return if (like != null) Money(q.first, q.second, like.cur) else Dec(q.first, q.second)
+    }
+
+    // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+    fun mod(a: Any?, b: Any?): Dec {
+        val x = integral(a); val y = integral(b)
+        if (x == null || y == null) throw Refused("§58: mod определён только для Integer")
+        if (y.signum() == 0) throw Refused("остаток от деления на ноль — evaluation error (§58)")
+        return Dec(x.mod(y.abs()), 0)
+    }
+
+    fun min(a: Any?, b: Any?): Dec { same(a, b, "min"); val (x, y, _) = pair(a as Dec, b as Dec); return if (x <= y) a else b as Dec }
+    fun max(a: Any?, b: Any?): Dec { same(a, b, "max"); val (x, y, _) = pair(a as Dec, b as Dec); return if (x >= y) a else b as Dec }
+
+    fun abs(v: Any?): Dec {
+        if (v !is Dec) throw Refused("§58: abs — не числовой вид")
+        return mk(v.u.abs(), v.s, v)
+    }
+
+    private val POW_MIN = BigInteger.valueOf(Long.MIN_VALUE)
+    private val POW_MAX = BigInteger.valueOf(Long.MAX_VALUE)
+
+    // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+    // вычисление, диапазон — часть контракта.
+    fun pow(base: Any?, exp: Any?): Dec {
+        val x = integral(base); val e = integral(exp)
+        if (x == null || e == null) throw Refused("§58: pow определён только для Integer")
+        if (e.signum() < 0) throw Refused("§58: pow — показатель отрицателен")
+        if (e > BigInteger.valueOf(4096)) throw Refused("RESOURCE_LIMIT: pow — показатель превышает 4096")
+        val r = x.pow(e.toInt())
+        if (r < POW_MIN || r > POW_MAX) throw Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+        return Dec(r, 0)
+    }
+
+    fun round(m: Any?, digits: Any?, mode: String): Dec {
+        if (mode != "HALF_UP") throw Refused("§50: режим округления не реализован: $mode")
+        if (m !is Dec) throw Refused("§50: round — не числовой вид")
+        val n = if (digits is Dec) (digits.u / p10(digits.s)).toInt() else 0
+        if (m.s <= n) return mk(m.u * p10(n - m.s), n, m)
+        val drop = p10(m.s - n)
+        val neg = m.u.signum() < 0
+        val qr = m.u.abs().divideAndRemainder(drop)
+        val up = if (qr[1].shiftLeft(1) >= drop) qr[0] + BigInteger.ONE else qr[0] // HALF_UP — от нуля
+        return mk(if (neg) up.negate() else up, n, m)
+    }
+
+    // --- сравнение и равенство -----------------------------------------------
+    private fun ordered(op: String, c: Int): Boolean = when (op) {
+        "lt" -> c < 0; "le" -> c <= 0; "gt" -> c > 0; "ge" -> c >= 0; "eq" -> c == 0; "ne" -> c != 0
+        else -> throw Refused("сравнение вне среза рантайма: $op")
+    }
+
+    fun cmp(a: Any?, op: String, b: Any?): Boolean {
+        if (a is Sym || b is Sym) {
+            val same = a is Sym && b is Sym && a.id == b.id
+            return when (op) { "eq" -> same; "ne" -> !same; else -> throw Refused("§57: вид enum не упорядочен") }
+        }
+        if (a is Date || b is Date) {
+            if (a is Date && b is Date) return ordered(op, a.v.compareTo(b.v))
+            return when (op) { "eq" -> false; "ne" -> true; else -> throw Refused("§57: Date сравнивается только с Date") }
+        }
+        if (a is String || b is String) {
+            val same = a is String && b is String && a == b
+            return when (op) { "eq" -> same; "ne" -> !same; else -> throw Refused("порядок на Text вне среза рантайма: $op") }
+        }
+        if ((a is Money) != (b is Money)) throw Refused("§49: сравнение денег с безразмерным")
+        if (a is Money && b is Money && a.cur != b.cur) throw Refused("§49: разные валюты")
+        val (x, y, _) = pair(a as Dec, b as Dec)
+        return ordered(op, x.compareTo(y))
+    }
+
+    fun eq(a: Any?, b: Any?): Boolean {
+        if (a is Sym || b is Sym) return a is Sym && b is Sym && a.id == b.id
+        if (a is Date || b is Date) return a is Date && b is Date && a.v == b.v
+        if (a is String || b is String) return a is String && b is String && a == b
+        if ((a is Money) != (b is Money)) return false
+        if (a is Money && b is Money && a.cur != b.cur) return false
+        val (x, y, _) = pair(a as Dec, b as Dec)
+        return x == y
+    }
+
+    private fun norm(d: Dec): String {
+        var u = d.u; var s = d.s
+        while (s > 0 && u.mod(BigInteger.TEN).signum() == 0) { u /= BigInteger.TEN; s-- }
+        return "${u}e-$s"
+    }
+    // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+    private fun esc(t: String) = t.replace("\\", "\\\\").replace("|", "\\|")
+
+    fun key(row: List<Any?>): String = row.joinToString("|") { v ->
+        when (v) {
+            is String -> "e:" + esc(v)
+            is Date -> "t:" + v.v
+            is Sym -> "c:" + esc(v.id)
+            is Money -> "m:" + v.cur + ":" + norm(v)
+            is Dec -> "d:" + norm(v)
+            else -> throw IllegalStateException("ключ: вид $v")
+        }
+    }
+
+    private var legalTimeValue = ""
+    fun setLegalTime(t: String) { legalTimeValue = t }
+    fun legalTime(): String {
+        if (legalTimeValue.isEmpty()) throw Refused("legalTime не подан делом")
+        return legalTimeValue
+    }
+}

arxo_codegen/targets/kt/emit.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Эмиттер Kotlin (JVM). Модель — объект `Model`; сборка `kotlinc` в jar с
+рантаймом Kotlin внутри, запуск `java -jar`."""
+import json
+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 jstr(s: str) -> str:
+    return json.dumps(s, ensure_ascii=False).replace("$", "\\$")
+
+
+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({jstr(t["v"])}, {jstr(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT.dec({jstr(t["v"])})'
+        if t["t"] == "date":
+            return f'RT.date({jstr(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT.sym({jstr(t["v"])})'
+        return jstr(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])}, {jstr(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 = ["object Model {",
+         "    val TABLES = LinkedHashMap<String, ArrayList<List<Any?>>>()",
+         "    // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).",
+         "    val PARAMS = LinkedHashMap<String, List<String>>()",
+         "    // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.",
+         "    val CONSTS = LinkedHashMap<String, Pair<String, Any>>()",
+         "    // Наследование сущностей: подтип подходит параметру базового типа.",
+         "    val BASES = LinkedHashMap<String, String>()",
+         "    // Ключи отношений §45.1: позиции столбцов каждого ключа.",
+         "    val KEYS = LinkedHashMap<String, List<List<Int>>>()",
+         "    val KEY_READERS = LinkedHashMap<String, List<String>>()",
+         "    private val seen = HashSet<String>()",
+         "",
+         "    init {"]
+    for t in plan["tables"]:
+        L.append(f'        TABLES[{jstr(t["pred"])}] = ArrayList()')
+        L.append(f'        PARAMS[{jstr(t["pred"])}] = listOf(' + ", ".join(jstr(p) for p in t["params"]) + ")")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'        KEYS[{jstr(t["pred"])}] = listOf(' + ", ".join("listOf(" + ", ".join(str(i) for i in k) + ")" for k in t["keys"]) + ")")
+    for source, consumers in key_readers(plan).items():
+        L.append(f'        KEY_READERS[{jstr(source)}] = listOf(' + ", ".join(jstr(value) for value in consumers) + ")")
+    for cid, c in plan["consts"].items():
+        L.append(f'        CONSTS[{jstr(cid)}] = Pair({jstr(c["type"])}, {term(c["term"])})')
+    for sub, base in plan["bases"].items():
+        L.append(f'        BASES[{jstr(sub)}] = {jstr(base)}')
+    L.append("    }")
+    L.append("")
+    L.append("    // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("    fun keyConflicts(): Int {")
+    L.append("        var n = 0")
+    L.append("        for ((urn, keys) in KEYS) {")
+    L.append("            for (key in keys) {")
+    L.append("                val groups = HashMap<String, Int>()")
+    L.append("                for (row in TABLES[urn]!!) {")
+    L.append("                    val p = RT.key(key.map { row[it] })")
+    L.append("                    groups[p] = (groups[p] ?: 0) + 1")
+    L.append("                }")
+    L.append("                n += groups.values.count { it > 1 }")
+    L.append("            }")
+    L.append("        }")
+    L.append("        return n")
+    L.append("    }")
+    L.append("    fun keyConflictPredicates(): MutableSet<String> {")
+    L.append("        val out = HashSet<String>()")
+    L.append("        for ((urn, keys) in KEYS) for (key in keys) { val groups = HashMap<String, Int>(); for (row in TABLES[urn]!!) { val p = RT.key(key.map { row[it] }); groups[p] = (groups[p] ?: 0) + 1 }; if (groups.values.any { it > 1 }) out.add(urn) }")
+    L.append("        return out")
+    L.append("    }")
+    L.append("")
+    L.append("    private fun addRow(urn: String, row: List<Any?>): Boolean {")
+    L.append('        if (!seen.add(urn + "#" + RT.key(row))) return false')
+    L.append("        TABLES[urn]!!.add(row)")
+    L.append("        return true")
+    L.append("    }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'    // {r["id"]}')
+        L.append(f'    private fun rule_{r["name"]}(): Boolean {{')
+        L.append("        var grew = false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'        if (RT.legalTime() < {jstr(r["window"]["start"])}) return false')
+            if r["window"].get("end"):
+                L.append(f'        if (RT.legalTime() >= {jstr(r["window"]["end"])}) return false')
+        ind = "        "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}for (r{i} in ArrayList(TABLES[{jstr(a["pred"])}]!!)) {{')
+            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 (addRow({jstr(r["head"]["pred"])}, listOf({args}))) grew = true')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("        return grew")
+        L.append("    }")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("    fun saturate() {")
+    L.append("        var grew = true")
+    L.append("        while (grew) {")
+    L.append("            grew = false")
+    for n in names:
+        L.append(f"            if (rule_{n}()) grew = true")
+    L.append("        }")
+    L.append("    }")
+    L.append("")
+    L.append("    fun register(urn: String, row: List<Any?>) { addRow(urn, row) }")
+    L.append("")
+    L.append("    fun packageFacts() {")
+    for f in plan["facts"]:
+        L.append(f'        addRow({jstr(f["pred"])}, listOf(' + ", ".join(term(a) for a in f["args"]) + "))")
+    L.append("    }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "kt"
+MODEL = "Model.kt"
+MAINS = {"runner": "Runner.kt", "cert": "Cert.kt"}
+
+
+def available():
+    kotlinc, java = shutil.which("kotlinc"), shutil.which("java")
+    return (True, kotlinc) if kotlinc and java else (False, "нет kotlinc/java в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("Runtime.kt", "Json.kt", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    proj = Path(proj)
+    return ["kotlinc", "-nowarn", "-include-runtime", "-d", "app.jar"] + sorted(p.name for p in proj.glob("*.kt")), str(proj)
+
+
+def run(proj, main: str):
+    return ["java", "-Dfile.encoding=UTF-8", "-jar", str(Path(proj) / "app.jar")], 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/lua/cert.lua

@@ -0,0 +1,82 @@
+-- Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+-- что получилось. Ожидания сверяют ворота, харнесс их не читает.
+local dir = arg[0]:match("^(.*)/") or "."
+package.path = dir .. "/?.lua;" .. package.path
+local RT = require("runtime")
+local J = require("json")
+
+local function lit(x)
+  if type(x) == "string" then return x end
+  if x.dec ~= nil then return RT.dec(x.dec) end
+  if x.money ~= nil then return RT.money(x.money, x.cur) end
+  if x.text ~= nil then return x.text end
+  if x.date ~= nil then return RT.date(x.date) end
+  if x.sym ~= nil then return RT.sym(x.sym) end
+  if x.row ~= nil then
+    local row = {}
+    for i, v in ipairs(x.row) do row[i] = lit(v) end
+    return row
+  end
+  error("литерал фикстуры")
+end
+
+-- Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+local function digits(u, s)
+  local body = RT.I.str(RT.I.absv(u))
+  if #body < s + 1 then body = string.rep("0", s + 1 - #body) .. body end
+  local text = body
+  if s > 0 then text = body:sub(1, #body - s) .. "." .. body:sub(#body - s + 1) end
+  return (u.neg and "-" or "") .. text
+end
+
+local function render(v)
+  if v == nil then return "null" end
+  if type(v) == "boolean" then return tostring(v) end
+  if type(v) == "string" then return J.str(v) end
+  if v.kind == "money" then return J.str(digits(v.u, v.s) .. " " .. v.cur) end
+  if v.kind == "date" then return J.str(v.v) end
+  if v.kind == "sym" then return J.str(v.id) end
+  return J.str(digits(v.u, v.s))
+end
+
+local OPS = {
+  dec = function(a) return RT.dec(a[1]) end,
+  money = function(a) return RT.money(a[1], a[2]) end,
+  date = function(a) return RT.date(a[1]) end,
+  sym = function(a) return RT.sym(a[1]) end,
+  mul = function(a) return RT.mul(a[1], a[2]) end,
+  add = function(a) return RT.add(a[1], a[2]) end,
+  sub = function(a) return RT.sub(a[1], a[2]) end,
+  div = function(a) return RT.div(a[1], a[2]) end,
+  mod = function(a) return RT.mod(a[1], a[2]) end,
+  min = function(a) return RT.min(a[1], a[2]) end,
+  max = function(a) return RT.max(a[1], a[2]) end,
+  abs = function(a) return RT.abs(a[1]) end,
+  pow = function(a) return RT.pow(a[1], a[2]) end,
+  round = function(a) return RT.round(a[1], a[2], a[3]) end,
+  cmp = function(a) return RT.cmp(a[1], a[2], a[3]) end,
+  eq = function(a) return RT.eq(a[1], a[2]) end,
+  keyEq = function(a) return RT.key(a[1]) == RT.key(a[2]) end,
+  legalTime = function() return RT.legalTime() end,
+  setLegalTime = function(a) RT.setLegalTime(a[1]) return nil end,
+}
+
+local fixture = J.read(arg[1])
+local out = {}
+for _, c in ipairs(fixture.cases) do
+  local f = OPS[c.op]
+  if f == nil then error("неизвестная операция фикстуры: " .. c.op) end
+  local args = {}
+  for i, x in ipairs(c.args) do args[i] = lit(x) end
+  local ok, res = pcall(f, args)
+  local got
+  if ok then
+    got = render(res)
+  elseif RT.is_refused(res) then
+    got = '{"refused":' .. J.str(res.msg) .. "}"
+  else
+    error(res, 0)
+  end
+  out[#out + 1] = '{"id":' .. J.str(c.id) .. ',"got":' .. got .. "}"
+end
+print("[" .. table.concat(out, ",") .. "]")