arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/scala/Runner.scala

@@ -0,0 +1,121 @@
+// Раннер Scala-бэкенда: тот же вход и тот же ответ, что у runner.rb.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+// целями; любое другое исключение — крах, который ворота валят.
+object Runner {
+  private val issues = scala.collection.mutable.ArrayBuffer.empty[String]
+  private var consts: Map[String, (String, V)] = Map.empty
+
+  def arg(a: J): V = a("kind").text match {
+    case "entity_ref" => Txt(a("id").text)
+    // §54: разыменование предшествует исполнению; член перечисления §38 либо
+    // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+    case "const_ref" => consts.get(a("id").text).map(_._2).getOrElse(RT.sym(a("id").text))
+    case "value" =>
+      val v = a("value").text
+      a("type")("name").text match {
+        case "urn:law:std#Money" => RT.money(v, a("currency").text)
+        case "urn:law:std#Decimal" | "urn:law:std#Integer" => RT.dec(v)
+        case "urn:law:std#Text" => Txt(v)
+        case "urn:law:std#Date" => RT.date(v)
+        case t => throw new Refused(s"аргумент вне среза раннера: $t")
+      }
+    case kind => throw new Refused(s"аргумент вне среза раннера: $kind")
+  }
+
+  // Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+  // константы; entity_ref типа не несёт (как у оракула).
+  def argType(a: J): Option[String] = a("kind").text match {
+    case "value" => a("type")("name").str
+    case "const_ref" => consts.get(a("id").text).map(_._1)
+    case _ => None
+  }
+
+  // Совпадение типа с наследованием сущностей вверх от фактического.
+  def conforms(actual: String, expected: String): Boolean = {
+    val seen = scala.collection.mutable.Set.empty[String]
+    var cur: Option[String] = Some(actual)
+    while (cur.isDefined && !seen.contains(cur.get)) {
+      if (cur.get == expected) return true
+      seen += cur.get
+      cur = Model.BASES.get(cur.get)
+    }
+    false
+  }
+
+  // Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+  def wellTyped(lit: J): Boolean = Model.PARAMS.get(lit("predicate").text) match {
+    case None => true
+    case Some(params) =>
+      val args = lit("args").items
+      val ok = args.length == params.length &&
+        params.zip(args).forall { case (expected, a) => argType(a).forall(conforms(_, expected)) }
+      if (!ok) issues += "TYPE_ERROR"
+      ok
+  }
+
+  // Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+  // атома не находит — NEITHER без issue.
+  def queryTyped(lit: J): Boolean = Model.PARAMS.get(lit("predicate").text) match {
+    case None => false
+    case Some(params) =>
+      val args = lit("args").items
+      args.length == params.length &&
+        params.zip(args).forall { case (expected, a) => argType(a).forall(conforms(_, expected)) }
+  }
+
+  def keyConflictBlocks(predicate: String): Boolean = {
+    val tainted = scala.collection.mutable.Set.from(Model.keyConflictPredicates())
+    val waiting = scala.collection.mutable.Stack.from(tainted)
+    while (waiting.nonEmpty) {
+      val source = waiting.pop()
+      for (consumer <- Model.KEY_READERS.getOrElse(source, Vector.empty) if !tainted.contains(consumer)) {
+        tainted += consumer
+        waiting.push(consumer)
+      }
+    }
+    tainted.contains(predicate)
+  }
+
+  def run(argv: Array[String]): Unit = {
+    val kase = Json.read(argv(0))
+    val query = Json.read(argv(1))
+    RT.setLegalTime(kase("context")("legalTime").text)
+    consts = Model.consts()
+    Model.packageFacts()
+    for (a <- kase("assertions").items) {
+      val lit = a("literal")
+      if (lit("polarity").text != "positive") throw new Refused("§113: отрицательный факт вне L0-среза")
+      if (wellTyped(lit) && Model.PARAMS.contains(lit("predicate").text)) {
+        Model.register(lit("predicate").text, lit("args").items.map(arg))
+      }
+    }
+    Model.saturate()
+    for (_ <- 0 until Model.keyConflicts()) issues += "KEY_CONFLICT"
+    val kind = query("kind").text
+    if (kind != "truth") throw new Refused(s"вид запроса вне среза раннера: $kind")
+    val ql = query("literal")
+    val hit = queryTyped(ql) && {
+      val want = ql("args").items.map(arg)
+      Model.TABLES.get(ql("predicate").text).exists(_.exists { r =>
+        r.length == want.length && r.indices.forall(i => RT.eq(r(i), want(i)))
+      })
+    }
+    // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+    Json.out.println("{\"queryId\":" + Json.str(query("queryId").text) +
+      ",\"truthStatus\":" + Json.str(if (hit) "TRUE_ONLY" else "NEITHER") +
+      ",\"evaluationStatus\":" + Json.str(if (keyConflictBlocks(ql("predicate").text)) "NON_EXECUTABLE" else "COMPUTED") + ",\"issues\":[" + issues.map(Json.str).mkString(",") + "]}")
+  }
+
+  def main(argv: Array[String]): Unit = {
+    try run(argv)
+    catch {
+      case e: Refused =>
+        Json.out.println("{\"refused\":" + Json.str(e.getMessage) + "}")
+        Json.out.flush()
+        sys.exit(3)
+    }
+    Json.out.flush()
+  }
+}

arxo_codegen/targets/scala/Runtime.scala

@@ -0,0 +1,269 @@
+// Рантайм L0 для Scala. Тот же контракт, что у runtime.rb: точная десятичная
+// арифметика §58 на BigInt, деньги с валютой, названный режим округления,
+// календарный день, член перечисления.
+//
+// Ловушки Scala: `%` у BigInt усекает к нулю (евклидов остаток — `mod`);
+// внутри `object RT` голый `max(...)` означает `RT.max`, поэтому целые
+// сравниваются через `math.max`.
+
+/** Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+ *  печатает его как JSON с кодом выхода 3; любое другое исключение — крах. */
+final class Refused(msg: String) extends Exception(msg)
+
+/** Значение ячейки. Text и сущность — `Txt`; календарный день §2.15 в
+ *  канонической записи ISO — `LDate` (порядок записи и есть порядок дня);
+ *  член перечисления §38 или ссылка без объявления — `Sym` (равенство по
+ *  идентичности, порядок не определён, §57). */
+sealed trait V
+final case class Txt(v: String) extends V
+final case class Dec(u: BigInt, s: Int) extends V
+final case class Money(u: BigInt, s: Int, cur: String) extends V
+final case class LDate(v: String) extends V
+final case class Sym(id: String) extends V
+
+object RT {
+  private def p10(k: Int): BigInt = BigInt(10).pow(k)
+
+  def dec(lit: String): V = {
+    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 digits = (if (neg) i.substring(1) else i) + f
+    Dec(BigInt((if (neg) "-" else "") + digits), f.length)
+  }
+
+  def money(lit: String, cur: String): V = dec(lit) match {
+    case Dec(u, s) => Money(u, s, cur)
+    case other => other
+  }
+
+  def date(lit: String): V = LDate(lit)
+  def sym(id: String): V = Sym(id)
+
+  /** Модуль, масштаб и валюта числа; None — не число. */
+  private def num(v: V): Option[(BigInt, Int, Option[String])] = v match {
+    case Dec(u, s) => Some((u, s, None))
+    case Money(u, s, cur) => Some((u, s, Some(cur)))
+    case _ => None
+  }
+
+  private def make(u: BigInt, s: Int, cur: Option[String]): V = cur match {
+    case Some(c) => Money(u, s, c)
+    case None => Dec(u, s)
+  }
+
+  // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+  private def same(a: V, b: V, op: String): ((BigInt, Int, Option[String]), (BigInt, Int, Option[String])) =
+    (num(a), num(b)) match {
+      case (Some(x), Some(y)) if x._3.isDefined == y._3.isDefined =>
+        if (x._3 != y._3) throw new Refused(s"§58: разные валюты: $op")
+        (x, y)
+      case _ => throw new Refused(s"§58: виды операндов не совпадают: $op")
+    }
+
+  private def pair(a: (BigInt, Int, Option[String]), b: (BigInt, Int, Option[String])): (BigInt, BigInt, Int) = {
+    val s = math.max(a._2, b._2)
+    (a._1 * p10(s - a._2), b._1 * p10(s - b._2), s)
+  }
+
+  // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+  private def integral(v: V): Option[BigInt] = v match {
+    case Dec(u, s) if (u % p10(s)) == 0 => Some(u / p10(s))
+    case _ => None
+  }
+
+  def add(a: V, b: V): V = {
+    val (x, y) = same(a, b, "add")
+    val (p, q, s) = pair(x, y)
+    make(p + q, s, x._3)
+  }
+
+  def sub(a: V, b: V): V = {
+    val (x, y) = same(a, b, "sub")
+    val (p, q, s) = pair(x, y)
+    make(p - q, s, x._3)
+  }
+
+  // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+  // сумма масштабов. Два размерных не перемножаются.
+  def mul(a: V, b: V): V = (num(a), num(b)) match {
+    case (Some(x), Some(y)) =>
+      if (x._3.isDefined && y._3.isDefined) throw new Refused("§58: произведение двух размерных величин не определено")
+      make(x._1 * y._1, x._2 + y._2, x._3.orElse(y._3))
+    case _ => throw new Refused("§58: виды операндов не совпадают: mul")
+  }
+
+  // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе None.
+  private def exact(num0: BigInt, den0: BigInt): Option[(BigInt, Int)] = {
+    var g = num0.gcd(den0)
+    if (g == 0) g = BigInt(1)
+    var num = num0 / g
+    var den = den0 / g
+    if (den < 0) { num = -num; den = -den }
+    var twos = 0
+    var fives = 0
+    while (den % 2 == 0) { den /= 2; twos += 1 }
+    while (den % 5 == 0) { den /= 5; fives += 1 }
+    if (den != 1) None
+    else {
+      val k = math.max(twos, fives)
+      Some((num * BigInt(2).pow(k - twos) * BigInt(5).pow(k - fives), k))
+    }
+  }
+
+  // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+  // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+  def div(a: V, b: V): V = (num(a), num(b)) match {
+    case (Some(x), Some(y)) =>
+      if (y._1 == 0) throw new Refused("деление на ноль — evaluation error (§58)")
+      val like: Option[String] = (x._3, y._3) match {
+        case (Some(c), Some(d)) =>
+          if (c != d) throw new Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+          None
+        case (Some(c), None) => Some(c)
+        case (None, Some(_)) => throw new Refused("§58: деление вне таблицы делимых")
+        case (None, None) => None
+      }
+      exact(x._1 * p10(y._2), y._1 * p10(x._2)) match {
+        case Some((qu, qs)) => make(qu, qs, like)
+        case None =>
+          if (like.isDefined) throw new Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)")
+          throw new Refused("§58: частное не 10-гладкое — Rational вне среза")
+      }
+    case _ => throw new Refused("§58: деление вне таблицы делимых")
+  }
+
+  // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+  def mod(a: V, b: V): V = (integral(a), integral(b)) match {
+    case (Some(x), Some(y)) =>
+      if (y == 0) throw new Refused("остаток от деления на ноль — evaluation error (§58)")
+      Dec(x.mod(y.abs), 0)
+    case _ => throw new Refused("§58: mod определён только для Integer")
+  }
+
+  def min(a: V, b: V): V = {
+    val (x, y) = same(a, b, "min")
+    val (p, q, _) = pair(x, y)
+    if (p <= q) a else b
+  }
+
+  def max(a: V, b: V): V = {
+    val (x, y) = same(a, b, "max")
+    val (p, q, _) = pair(x, y)
+    if (p >= q) a else b
+  }
+
+  def abs(v: V): V = num(v) match {
+    case Some((u, s, cur)) => make(u.abs, s, cur)
+    case None => throw new Refused("§58: abs — не числовой вид")
+  }
+
+  private val PowMin = -(BigInt(1) << 63)
+  private val PowMax = (BigInt(1) << 63) - 1
+
+  // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+  // вычисление, диапазон — часть контракта.
+  def pow(base: V, exp: V): V = (integral(base), integral(exp)) match {
+    case (Some(b), Some(e)) =>
+      if (e < 0) throw new Refused("§58: pow — показатель отрицателен")
+      if (e > 4096) throw new Refused("RESOURCE_LIMIT: pow — показатель превышает 4096")
+      val r = b.pow(e.toInt)
+      if (r < PowMin || r > PowMax) throw new Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+      Dec(r, 0)
+    case _ => throw new Refused("§58: pow определён только для Integer")
+  }
+
+  def round(m: V, digits: V, mode: String): V = {
+    if (mode != "HALF_UP") throw new Refused(s"§50: режим округления не реализован: $mode")
+    val (u, s, cur) = num(m).getOrElse(throw new Refused("§50: round — не числовой вид"))
+    val n = digits match {
+      case Dec(du, ds) => (du / p10(ds)).toInt
+      case _ => throw new Refused("§50: round — не числовой вид")
+    }
+    if (s <= n) make(u * p10(n - s), n, cur)
+    else {
+      val drop = p10(s - n)
+      val (q, r) = u.abs /% drop
+      val up = if (r * 2 >= drop) q + 1 else q // HALF_UP — от нуля
+      make(if (u < 0) -up else up, n, cur)
+    }
+  }
+
+  private def order(op: String, c: Int): Boolean = op match {
+    case "lt" => c < 0
+    case "le" => c <= 0
+    case "gt" => c > 0
+    case "ge" => c >= 0
+    case "eq" => c == 0
+    case "ne" => c != 0
+    case _ => throw new Refused(s"сравнение вне среза рантайма: $op")
+  }
+
+  /** Порядок записей по кодовым точкам: у записи ISO он и есть порядок дня. */
+  def strOrder(a: String, b: String): Int = Integer.signum(a.compareTo(b))
+
+  def cmp(a: V, op: String, b: V): Boolean = (a, b) match {
+    case (_: Sym, _) | (_, _: Sym) =>
+      val same = (a, b) match { case (Sym(x), Sym(y)) => x == y; case _ => false }
+      if (op == "eq") same
+      else if (op == "ne") !same
+      else throw new Refused("§57: вид enum не упорядочен")
+    case (LDate(x), LDate(y)) => order(op, strOrder(x, y))
+    case (_: LDate, _) | (_, _: LDate) =>
+      if (op == "eq") false
+      else if (op == "ne") true
+      else throw new Refused("§57: Date сравнивается только с Date")
+    case (_: Txt, _) | (_, _: Txt) =>
+      if (op == "eq") a == b
+      else if (op == "ne") a != b
+      else throw new Refused(s"порядок на Text вне среза рантайма: $op")
+    case _ =>
+      val x = num(a).get
+      val y = num(b).get
+      if (x._3.isDefined != y._3.isDefined) throw new Refused("§49: сравнение денег с безразмерным")
+      if (x._3 != y._3) throw new Refused("§49: разные валюты")
+      val (p, q, _) = pair(x, y)
+      order(op, p.compare(q))
+  }
+
+  def eq(a: V, b: V): Boolean = (a, b) match {
+    case (_: Sym, _) | (_, _: Sym) | (_: LDate, _) | (_, _: LDate) | (_: Txt, _) | (_, _: Txt) => a == b
+    case _ =>
+      val x = num(a).get
+      val y = num(b).get
+      if (x._3 != y._3) false
+      else {
+        val (p, q, _) = pair(x, y)
+        p == q
+      }
+  }
+
+  private def norm(u0: BigInt, s0: Int): String = {
+    var u = u0
+    var s = s0
+    while (s > 0 && u % 10 == 0) { u /= 10; s -= 1 }
+    s"${u}e-$s"
+  }
+
+  // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+  // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+  private def esc(text: String): String = text.replace("\\", "\\\\").replace("|", "\\|")
+
+  def key(row: Seq[V]): String = row.map {
+    case Txt(t) => "e:" + esc(t)
+    case LDate(d) => "t:" + d
+    case Sym(id) => "c:" + esc(id)
+    case Money(u, s, cur) => "m:" + cur + ":" + norm(u, s)
+    case Dec(u, s) => "d:" + norm(u, s)
+  }.mkString("|")
+
+  private var legal = ""
+
+  def setLegalTime(t: String): Unit = legal = t
+
+  def legalTime(): String = {
+    if (legal.isEmpty) throw new Refused("legalTime не подан делом")
+    legal
+  }
+}

arxo_codegen/targets/scala/emit.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Эмиттер Scala. Тот же план и тот же контракт рантайма; модель — `object
+Model` с изменяемыми таблицами, отказ — исключение `Refused`."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+MUT = "scala.collection.mutable"
+
+
+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:
+    """Строковый литерал Scala: экраны JSON (`\\uXXXX`, `\\n`, `\\"`) Scala
+    понимает, `$` в обычной строке не интерполируется."""
+    return json.dumps(s, ensure_ascii=False)
+
+
+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'Txt({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 listing(items: list, indent: str) -> str:
+    """Перечень аргументов по строке на элемент, без висячей запятой."""
+    return ("\n" + ",\n".join(indent + x for x in items) + "\n" + indent[:-2]) if items else ""
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["object Model {"]
+    L.append(f"  val TABLES: {MUT}.LinkedHashMap[String, {MUT}.ArrayBuffer[Vector[V]]] = {MUT}.LinkedHashMap(" +
+             listing([f'{ss(t["pred"])} -> {MUT}.ArrayBuffer.empty[Vector[V]]' for t in plan["tables"]], "    ") + ")")
+    L.append("  // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("  val PARAMS: Map[String, Vector[String]] = Map(" +
+             listing([f'{ss(t["pred"])} -> Vector(' + ", ".join(ss(p) for p in t["params"]) + ")"
+                      for t in plan["tables"]], "    ") + ")")
+    L.append("  // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("  def consts(): Map[String, (String, V)] = Map(" +
+             # Двойные скобки: `a -> (b, c)` Scala 3 читает как два аргумента `->`.
+             listing([f'{ss(cid)} -> (({ss(c["type"])}, {term(c["term"])}))' for cid, c in plan["consts"].items()],
+                     "    ") + ")")
+    L.append("  // Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("  val BASES: Map[String, String] = Map(" +
+             listing([f"{ss(sub)} -> {ss(base)}" for sub, base in plan["bases"].items()], "    ") + ")")
+    L.append("  // Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("  val KEYS: Vector[(String, Vector[Vector[Int]])] = Vector(" +
+             listing([f'({ss(t["pred"])}, Vector(' + ", ".join("Vector(" + ", ".join(map(str, k)) + ")" for k in t["keys"]) + "))"
+                      for t in plan["tables"] if t["keys"]], "    ") + ")")
+    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"])
+    L.append("  // E-0210/E-0242: forward readers of a keyed relation.")
+    L.append("  val KEY_READERS: Map[String, Vector[String]] = Map(" +
+             listing([f'{ss(source)} -> Vector(' + ", ".join(ss(value) for value in sorted(consumers)) + ")"
+                      for source, consumers in sorted(readers.items())], "    ") + ")")
+    L.append(f"  private val seen = {MUT}.Map.empty[String, {MUT}.Set[String]]")
+    L.append("")
+    L.append("  private def addRow(urn: String, row: Vector[V]): Boolean =")
+    L.append(f"    if (!seen.getOrElseUpdate(urn, {MUT}.Set.empty[String]).add(RT.key(row))) false")
+    L.append("    else { TABLES(urn) += row; true }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'  // {r["id"]}')
+        L.append(f'  private def rule_{r["name"]}(): Boolean = {{')
+        L.append("    var grew = false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'    if (RT.strOrder(RT.legalTime(), {ss(r["window"]["start"])}) < 0) return false')
+            if r["window"].get("end"):
+                L.append(f'    if (RT.strOrder(RT.legalTime(), {ss(r["window"]["end"])}) >= 0) return false')
+        ind = "    "
+        for i, a in enumerate(r["atoms"]):
+            # `toVector` — снимок таблицы на входе в цикл.
+            L.append(f'{ind}for (r{i} <- TABLES({ss(a["pred"])}).toVector) {{')
+            ind += "  "
+        conds = []
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            conds.append(f'RT.cmp(r{ai}({aj}), "eq", r{bi}({bj}))')
+        for f in r["filters"]:
+            conds.append(f'RT.eq(r{f["row"]}({f["col"]}), {term(f["term"])})')
+        for g in r["guards"]:
+            conds.append(f'RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        add = f'if (addRow({ss(r["head"]["pred"])}, Vector[V]({args}))) grew = true'
+        if conds:
+            # `&&` вычисляется по порядку и обрывается на первом ложном — тот же
+            # порядок отсева и тех же отказов, что у `next unless` в Ruby.
+            L.append(f"{ind}if (" + " && ".join(conds) + ") {")
+            L.append(f"{ind}  {add}")
+            L.append(f"{ind}}}")
+        else:
+            L.append(f"{ind}{add}")
+        for _ in r["atoms"]:
+            ind = ind[:-2]
+            L.append(ind + "}")
+        L.append("    grew")
+        L.append("  }")
+        L.append("")
+    L.append("  def saturate(): Unit = {")
+    L.append("    var grew = true")
+    L.append("    while (grew) {")
+    L.append("      grew = false")
+    for r in plan["rules"]:
+        L.append(f'      if (rule_{r["name"]}()) grew = true')
+    L.append("    }")
+    L.append("  }")
+    L.append("")
+    L.append("  def register(urn: String, row: Vector[V]): Boolean = addRow(urn, row)")
+    L.append("")
+    L.append("  // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("  def keyConflicts(): Int = KEYS.map { case (urn, keys) =>")
+    L.append("    keys.map(key => TABLES(urn).groupBy(row => RT.key(key.map(row(_)))).count(_._2.size > 1)).sum")
+    L.append("  }.sum")
+    L.append("")
+    L.append("  def keyConflictPredicates(): Set[String] = KEYS.flatMap { case (urn, keys) =>")
+    L.append("    if (keys.exists(key => TABLES(urn).groupBy(row => RT.key(key.map(row(_)))).exists(_._2.size > 1))) Some(urn) else None")
+    L.append("  }.toSet")
+    L.append("")
+    L.append("  // Собственные факты пакета: раннер кладёт их до фактов дела.")
+    L.append("  def packageFacts(): Unit = {")
+    for f in plan["facts"]:
+        L.append(f'    addRow({ss(f["pred"])}, Vector[V](' + ", ".join(term(a) for a in f["args"]) + "))")
+    L.append("  }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "scala"
+MODEL = "Model.scala"
+MAINS = {"runner": "Runner.scala", "cert": "Cert.scala"}
+
+
+def available():
+    cli = shutil.which("scala-cli")
+    return (True, cli) if cli else (False, "нет scala-cli в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("Runtime.scala", "Json.scala", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    return ["scala-cli", "compile", "-q", str(proj)], None
+
+
+def run(proj, main: str):
+    return ["scala-cli", "run", "-q", str(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")