arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/go/runtime.go

@@ -0,0 +1,2612 @@
+package main
+
+// Рантайм L0 для Go. Тот же контракт, что у runtime.ts и runtime.py:
+// точная десятичная арифметика §58, деньги с валютой, названный режим
+// округления, календарный день, член перечисления.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Val interface{}
+
+// Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+// восстанавливает его из panic и печатает как JSON с кодом выхода 3; любая
+// другая panic — крах, который ворота валят.
+type Refused string
+
+func refuse(msg string) {
+	panic(Refused(msg))
+}
+
+// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD: порядок
+// записи и есть порядок дня. Не string: у ключа атома и у сравнения свой вид.
+type Date string
+
+var dateRe = regexp.MustCompile(`^[0-9]{4}-[0-9]{2}-[0-9]{2}$`)
+
+func strictDay(raw string) time.Time {
+	t, err := time.Parse("2006-01-02", raw)
+	if !dateRe.MatchString(raw) || err != nil || t.Year() < 1 || t.Year() > 9999 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return t
+}
+func date(lit string) Date { strictDay(lit); return Date(lit) }
+
+// §82.2: record identity stays separate from the exact moment.
+type Instant string
+
+func instant(lit string) Instant { exactMoment(Instant(lit)); return Instant(lit) }
+
+var instantRe = regexp.MustCompile(`^([0-9]{4}-[0-9]{2}-[0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?(Z|[+-][0-9]{2}:[0-9]{2})$`)
+
+type instantMoment struct {
+	seconds  int64
+	fraction string
+}
+
+func exactMoment(v Instant) instantMoment {
+	m := instantRe.FindStringSubmatch(string(v))
+	if m == nil {
+		panic(termError{"TYPE_ERROR"})
+	}
+	day := strictDay(m[1])
+	h, _ := strconv.Atoi(m[2])
+	mi, _ := strconv.Atoi(m[3])
+	sec, _ := strconv.Atoi(m[4])
+	if h > 23 || mi > 59 || sec > 59 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	offset := 0
+	if m[6] != "Z" {
+		oh, _ := strconv.Atoi(m[6][1:3])
+		om, _ := strconv.Atoi(m[6][4:6])
+		if oh > 23 || om > 59 {
+			panic(termError{"TYPE_ERROR"})
+		}
+		offset = oh*3600 + om*60
+		if m[6][0] == '-' {
+			offset = -offset
+		}
+	}
+	return instantMoment{day.Unix() + int64(h*3600+mi*60+sec-offset), strings.TrimRight(m[5], "0")}
+}
+func momentCmp(a, b Instant) int {
+	x, y := exactMoment(a), exactMoment(b)
+	if x.seconds < y.seconds {
+		return -1
+	}
+	if x.seconds > y.seconds {
+		return 1
+	}
+	return strings.Compare(x.fraction, y.fraction)
+}
+func validateTemporalCase(raw []byte) {
+	var kase map[string]interface{}
+	if json.Unmarshal(raw, &kase) != nil {
+		return
+	}
+	assertions, _ := kase["assertions"].([]interface{})
+	for i, value := range assertions {
+		a, _ := value.(map[string]interface{})
+		w, present := a["valid"]
+		if !present {
+			continue
+		}
+		base := fmt.Sprintf("TEMPORAL_BOUND_INVALID: request:/case/assertions/%d/valid", i)
+		interval, ok := w.(map[string]interface{})
+		if !ok {
+			refuse(base)
+		}
+		for _, side := range []string{"start", "end"} {
+			v, present := interval[side]
+			if !present {
+				continue
+			}
+			text, ok := v.(string)
+			sentinel := "infinity"
+			if side == "start" {
+				sentinel = "-infinity"
+			}
+			if ok && text == sentinel {
+				continue
+			}
+			func() {
+				defer func() {
+					if e := recover(); e != nil {
+						if _, ok := e.(termError); ok {
+							refuse(base + "/" + side)
+						}
+						panic(e)
+					}
+				}()
+				if !ok {
+					panic(termError{"TYPE_ERROR"})
+				}
+				if dateRe.MatchString(text) {
+					strictDay(text)
+				} else {
+					exactMoment(Instant(text))
+				}
+			}()
+		}
+	}
+}
+
+// Член перечисления §38 либо иная ссылка const_ref без объявления: значение —
+// stable qualified identity, равенство по ней (§57), порядок не определён.
+type Sym string
+
+func sym(id string) Sym { return Sym(id) }
+
+type Dec struct {
+	U *big.Int
+	S int
+}
+
+type Money struct {
+	U   *big.Int
+	S   int
+	Cur string
+}
+
+func p10(n int) *big.Int {
+	return new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(n)), nil)
+}
+
+func dec(lit string) Dec { return litDec("s", lit) }
+
+func money(lit, cur string) Money {
+	d := dec(lit)
+	return Money{U: d.U, S: d.S, Cur: cur}
+}
+
+// Quantity §49 v1 (DECISION-0256 п. 5): точное десятичное и тег единицы —
+// байты записи; реестра единиц и алиасов §49.2 здесь нет. Не Money: у ключа
+// и у сравнения свой вид, 1 KZT денег и величина 1 [KZT] — разные значения.
+// Неизменяема: мантисса не мутируется, операции строят new(big.Int).
+type Qty struct {
+	U    *big.Int
+	S    int
+	Unit string
+}
+
+// Величина §49: значение и тег единицы как записаны.
+func qty(lit, unit string) Qty {
+	d := dec(lit)
+	return Qty{U: d.U, S: d.S, Unit: unit}
+}
+
+func isQty(v Val) bool {
+	_, ok := v.(Qty)
+	return ok
+}
+
+// Rational §35 (DECISION-0252 п. 6): несократимая дробь на целых произвольной
+// длины, знаменатель положителен, ноль — 0/1. Не Dec: у ключа строки и у
+// сравнения свой вид, 2/1 и Decimal 2 — разные значения §48. Неизменяема:
+// поля строятся только конструктором, операции над ними берут new(big.Int).
+type Rational struct {
+	N *big.Int
+	D *big.Int
+}
+
+func newRat(n, d *big.Int) Rational {
+	if d.Sign() == 0 {
+		panic(termError{"DIVISION_BY_ZERO"})
+	}
+	num, den := new(big.Int).Set(n), new(big.Int).Set(d)
+	if den.Sign() < 0 {
+		num.Neg(num)
+		den.Neg(den)
+	}
+	g := new(big.Int).GCD(nil, nil, new(big.Int).Abs(num), den)
+	if g.Sign() == 0 {
+		g = big.NewInt(1)
+	}
+	return Rational{N: num.Quo(num, g), D: den.Quo(den, g)}
+}
+
+// --- сырое поле литерала §208 -------------------------------------------------
+// Правило одно на три цели (errata E-0197, E-0202, E-0203): сырое поле литерала
+// читается НЕ средствами языка цели, а по грамматике §208. `int()` и `Decimal()`
+// Python берут пробел, `_` и юникодную цифру; `Number()` JavaScript берёт `1e2`
+// и `Infinity` и теряет точность выше 2^53; `strconv` и `math/big` Go имеют свои
+// допуски (`SetString` с базой 0 разрешает `_`). Норма у всех одна, поэтому
+// алфавит назван явно и одинаково.
+
+// §18/§208 (errata E-0203): лексика ЗАПИСИ десятичного значения — дословный
+// порт `lawref/values.py::_DECIMAL_LEXIS`. Экспонента, ведущие и хвостовые
+// нули, знак `+`, `.5` и `5.` остаются законной записью входа и нормализуются;
+// сужены ровно пробельный символ, `_`, не-ASCII цифра и `Infinity`/`NaN`.
+// `$` в RE2 без флага `m` — конец ТЕКСТА (как `\z`), хвостового перевода
+// строки, из-за которого оракулу понадобился `\Z`, он не пропускает.
+var decimalLexis = regexp.MustCompile(`^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$`)
+
+// §35/§208 (errata E-0203): лексика ЦЕЛОГО внутри записи `<n>/<d>`.
+var fractionPartLexis = regexp.MustCompile(`^[+-]?[0-9]+$`)
+
+// §208 (errata E-0202): знаковый 64-битный носитель JSON-числа канона.
+var i64Min = new(big.Int).Neg(new(big.Int).Lsh(big.NewInt(1), 63))
+var i64Max = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 63), big.NewInt(1))
+
+// Канон §208 отвергает JSON-float и целое вне i64 ОТКАЗОМ СОБРАТЬ ДОКУМЕНТ
+// (error-объект §172), а не issue. У порождённого модуля канала error-объекта
+// нет — профиль core-executable документа не строит, — поэтому тот же вход даёт
+// названный отказ раннера: «меньше ответа», а не другой ответ.
+const canonNumber = "JSON-число вне канона §208 (только целое знакового 64-битного диапазона) вне среза раннера"
+
+// Текст JSON-числа канона: целое в i64 — его цифрами, всё прочее — отказ.
+func canonNumberText(s string) (string, string) {
+	n, ok := new(big.Int).SetString(s, 10)
+	if !ok || n.Cmp(i64Min) < 0 || n.Cmp(i64Max) > 0 {
+		refuse(canonNumber)
+	}
+	return "i", n.String()
+}
+
+// Поле, чей канон §208 — JSON-строка (Text, Date, Instant, Rational, валюта,
+// единица). Порт `values._json_string`: до E-0197 цели приводили к строке ЛЮБОЙ
+// JSON, и литерал без `value` выходил значением "" у go и "undefined" у ts —
+// расхождение в результате, а не в тексте issue.
+func litText(k, text string) string {
+	if k != "s" {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return text
+}
+
+// Поле, чей канон §208 — целое JSON-число (Integer). Порт `values._json_int`.
+func litIntText(k, text string) string {
+	if k != "i" {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return text
+}
+
+// Поле Decimal/Money/Quantity: строка по лексике §208 либо целое JSON-число
+// (запись числом остаётся законной — E-0203, долг п. 3).
+func litDecText(k, text string) string {
+	if k == "i" {
+		return text
+	}
+	if k != "s" || !decimalLexis.MatchString(text) {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return text
+}
+
+// Точное десятичное из записи, уже прошедшей decimalLexis: знак, необязательная
+// экспонента, `.5` и `5.`. Нормализация — как у `Decimal(text)` оракула, чей
+// канон §208 печатает non-exponent форму.
+func decLexis(text string) Dec {
+	body := text
+	neg := strings.HasPrefix(body, "-")
+	if neg || strings.HasPrefix(body, "+") {
+		body = body[1:]
+	}
+	exp := 0
+	if at := strings.IndexAny(body, "eE"); at >= 0 {
+		n, err := strconv.Atoi(body[at+1:])
+		if err != nil {
+			panic(termError{"TYPE_ERROR"})
+		}
+		exp = n
+		body = body[:at]
+	}
+	intPart, frac, _ := strings.Cut(body, ".")
+	digits := intPart + frac
+	if digits == "" {
+		digits = "0"
+	}
+	u, ok := new(big.Int).SetString(digits, 10)
+	if !ok {
+		panic(termError{"TYPE_ERROR"})
+	}
+	s := len(frac) - exp
+	if u.Sign() == 0 && (s > 4096 || s < -4096) {
+		return Dec{U: big.NewInt(0), S: 0}
+	}
+	canonicalScale := s - (len(digits) - len(strings.TrimRight(digits, "0")))
+	if u.Sign() != 0 && (canonicalScale > 4096 || s < -4096) {
+		refuse("DECIMAL_EXPANSION_UNAVAILABLE: E-0320 limit 4096")
+	}
+	if s < 0 {
+		u.Mul(u, p10(-s))
+		s = 0
+	}
+	if neg {
+		u.Neg(u)
+	}
+	return Dec{U: u, S: s}
+}
+
+func litDec(k, text string) Dec { return decLexis(litDecText(k, text)) }
+func litInt(k, text string) Dec { return decLexis(litIntText(k, text)) }
+func litMoney(k, text, ck, ctext string) Money {
+	d := litDec(k, text)
+	return Money{U: d.U, S: d.S, Cur: litText(ck, ctext)}
+}
+func litQty(k, text string, uk, utext string) Qty {
+	d := litDec(k, text)
+	return Qty{U: d.U, S: d.S, Unit: litText(uk, utext)}
+}
+
+// Литерал Rational в вычислимом терме вопроса `term`: разбор оракула
+// (`values.from_literal_term`) — запись `n/d` с целыми частями по лексике §208
+// (E-0203), сократимая и со знаком в знаменателе нормализуется; не `n/d` —
+// TYPE_ERROR, знаменатель 0 — DIVISION_BY_ZERO. Каноничность §168.1 требуется
+// от записей дела и вопроса `truth`, не от операнда вычисления (ERR-E0005).
+func ratTerm(lit string) Rational {
+	parts := strings.Split(lit, "/")
+	if len(parts) != 2 || !fractionPartLexis.MatchString(parts[0]) || !fractionPartLexis.MatchString(parts[1]) {
+		panic(termError{"TYPE_ERROR"})
+	}
+	n, _ := new(big.Int).SetString(parts[0], 10)
+	d, _ := new(big.Int).SetString(parts[1], 10)
+	return newRat(n, d)
+}
+
+var ratCanon = regexp.MustCompile(`^(0|-?[1-9][0-9]*)/([1-9][0-9]*)$`)
+
+// Каноническая запись n/d (§168.1): иная — названный отказ, а не молчаливое
+// сокращение — оракул хранит запись как есть, и сокращённая дала бы другой ответ.
+func rat(lit string) Rational {
+	num, den, _ := strings.Cut(lit, "/")
+	if !fractionPartLexis.MatchString(num) || !fractionPartLexis.MatchString(den) {
+		refuse("§168.1: запись Rational не n/d: " + lit)
+	}
+	m := ratCanon.FindStringSubmatch(lit)
+	if m == nil {
+		refuse("§168.1: неканоническая запись Rational: " + lit)
+	}
+	n, _ := new(big.Int).SetString(m[1], 10)
+	d, _ := new(big.Int).SetString(m[2], 10)
+	if new(big.Int).GCD(nil, nil, new(big.Int).Abs(n), d).Cmp(big.NewInt(1)) != 0 {
+		refuse("§168.1: неканоническая запись Rational: " + lit)
+	}
+	return newRat(n, d)
+}
+
+// --- виды -------------------------------------------------------------------
+
+// Числовое значение: мантисса, масштаб, валюта, «это деньги», «это число».
+// Величина — число не-денег: тег проверяют `same`, `cmp` и `eq` раньше.
+func scaled(v Val) (*big.Int, int, string, bool, bool) {
+	switch x := v.(type) {
+	case Money:
+		return x.U, x.S, x.Cur, true, true
+	case Qty:
+		return x.U, x.S, "", false, true
+	case Dec:
+		return x.U, x.S, "", false, true
+	}
+	return nil, 0, "", false, false
+}
+
+// §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и
+// валюты, у величин — и единицы (DECISION-0256: ошибка значения).
+func same(a, b Val, op string) {
+	if isQty(a) || isQty(b) {
+		x, xok := a.(Qty)
+		y, yok := b.(Qty)
+		if !xok || !yok {
+			panic(termError{"TYPE_ERROR"})
+		}
+		if x.Unit != y.Unit {
+			panic(termError{"DIMENSION_MISMATCH"})
+		}
+		return
+	}
+	_, _, ac, am, aok := scaled(a)
+	_, _, bc, bm, bok := scaled(b)
+	if !aok || !bok || am != bm {
+		refuse("§58: виды операндов не совпадают: " + op)
+	}
+	if am && ac != bc {
+		refuse("§58: разные валюты: " + op)
+	}
+}
+
+func pair(a, b Val) (*big.Int, *big.Int, int) {
+	au, as, _, _, _ := scaled(a)
+	bu, bs, _, _, _ := scaled(b)
+	s := as
+	if bs > s {
+		s = bs
+	}
+	x, y := new(big.Int).Mul(au, p10(s-as)), new(big.Int).Mul(bu, p10(s-bs))
+	boundedCoefficient(x, s)
+	boundedCoefficient(y, s)
+	return x, y, s
+}
+
+func mk(u *big.Int, s int, like Val) Val {
+	boundedCoefficient(u, s)
+	if q, ok := like.(Qty); ok {
+		return Qty{U: u, S: s, Unit: q.Unit}
+	}
+	if m, ok := like.(Money); ok {
+		return Money{U: u, S: s, Cur: m.Cur}
+	}
+	return Dec{U: u, S: s}
+}
+
+// Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+func integral(v Val) (*big.Int, bool) {
+	d, ok := v.(Dec)
+	if !ok {
+		return nil, false
+	}
+	q, r := new(big.Int).QuoRem(d.U, p10(d.S), new(big.Int))
+	if r.Sign() != 0 {
+		return nil, false
+	}
+	return q, true
+}
+
+// --- арифметика §58 ---------------------------------------------------------
+
+func isRat(v Val) bool {
+	_, ok := v.(Rational)
+	return ok
+}
+
+func add(a, b Val) Val {
+	if isRat(a) || isRat(b) {
+		return ratPair(a, b, "add")
+	}
+	same(a, b, "add")
+	x, y, s := pair(a, b)
+	return mk(new(big.Int).Add(x, y), s, a)
+}
+
+func sub(a, b Val) Val {
+	if isRat(a) || isRat(b) {
+		return ratPair(a, b, "sub")
+	}
+	same(a, b, "sub")
+	x, y, s := pair(a, b)
+	return mk(new(big.Int).Sub(x, y), s, a)
+}
+
+// Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+// сумма масштабов. Два размерных не перемножаются.
+func mul(a, b Val) Val {
+	au, as, _, am, aok := scaled(a)
+	bu, bs, _, bm, bok := scaled(b)
+	if !aok || !bok {
+		refuse("§58: виды операндов не совпадают: mul")
+	}
+	// Размерное — деньги либо величина §49 (DECISION-0256).
+	am, bm = am || isQty(a), bm || isQty(b)
+	if am && bm {
+		refuse("§58: произведение двух размерных величин не определено")
+	}
+	like := b
+	if am {
+		like = a
+	}
+	return mk(new(big.Int).Mul(au, bu), as+bs, like)
+}
+
+// Точное десятичное частное num/den при 10-гладком знаменателе (§18).
+func exact(num, den *big.Int) (*big.Int, int, bool) {
+	g := new(big.Int).GCD(nil, nil, new(big.Int).Abs(num), new(big.Int).Abs(den))
+	if g.Sign() == 0 {
+		g = big.NewInt(1)
+	}
+	num = new(big.Int).Quo(num, g)
+	den = new(big.Int).Quo(den, g)
+	if den.Sign() < 0 {
+		num.Neg(num)
+		den.Neg(den)
+	}
+	two, five := big.NewInt(2), big.NewInt(5)
+	twos, fives := 0, 0
+	for new(big.Int).Mod(den, two).Sign() == 0 {
+		den.Quo(den, two)
+		twos++
+	}
+	for new(big.Int).Mod(den, five).Sign() == 0 {
+		den.Quo(den, five)
+		fives++
+	}
+	if den.Cmp(big.NewInt(1)) != 0 {
+		return nil, 0, false
+	}
+	k := twos
+	if fives > k {
+		k = fives
+	}
+	out := new(big.Int).Mul(num, new(big.Int).Exp(two, big.NewInt(int64(k-twos)), nil))
+	out.Mul(out, new(big.Int).Exp(five, big.NewInt(int64(k-fives)), nil))
+	return out, k, true
+}
+
+// Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+// валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+func div(a, b Val) Val {
+	au, as, ac, am, aok := scaled(a)
+	bu, bs, bc, bm, bok := scaled(b)
+	if !aok || !bok {
+		refuse("§58: деление вне таблицы делимых")
+	}
+	if bu.Sign() == 0 {
+		refuse("деление на ноль — evaluation error (§58)")
+	}
+	var like Val
+	switch {
+	case am && bm:
+		if ac != bc {
+			refuse("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+		}
+	case am:
+		like = a
+	case bm:
+		refuse("§58: деление вне таблицы делимых")
+	}
+	u, s, ok := exact(new(big.Int).Mul(au, p10(bs)), new(big.Int).Mul(bu, p10(as)))
+	if !ok {
+		if like != nil {
+			refuse("INEXACT_DIVISION: округление только явной политикой (§50/§18)")
+		}
+		refuse("§58: частное не 10-гладкое — Rational вне среза")
+	}
+	if like != nil {
+		return Money{U: u, S: s, Cur: like.(Money).Cur}
+	}
+	return Dec{U: u, S: s}
+}
+
+// Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+func mod(a, b Val) Val {
+	x, xok := integral(a)
+	y, yok := integral(b)
+	if !xok || !yok {
+		refuse("§58: mod определён только для Integer")
+	}
+	if y.Sign() == 0 {
+		refuse("остаток от деления на ноль — evaluation error (§58)")
+	}
+	m := new(big.Int).Abs(y)
+	r := new(big.Int).Mod(x, m) // big.Int.Mod — евклидов
+	return Dec{U: r, S: 0}
+}
+
+// --- Rational §35/§58 и арифметика по видам (DECISION-0252) ------------------
+
+func mulInt(a, b *big.Int) *big.Int { return new(big.Int).Mul(a, b) }
+
+// add/sub/min/max над Rational: оба операнда Rational, иначе TYPE_ERROR §48.
+func ratPair(a, b Val, op string) Val {
+	x, xok := a.(Rational)
+	y, yok := b.(Rational)
+	if !xok || !yok {
+		panic(termError{"TYPE_ERROR"})
+	}
+	switch op {
+	case "add":
+		return newRat(new(big.Int).Add(mulInt(x.N, y.D), mulInt(y.N, x.D)), mulInt(x.D, y.D))
+	case "sub":
+		return newRat(new(big.Int).Sub(mulInt(x.N, y.D), mulInt(y.N, x.D)), mulInt(x.D, y.D))
+	case "min":
+		if mulInt(x.N, y.D).Cmp(mulInt(y.N, x.D)) <= 0 {
+			return a
+		}
+		return b
+	}
+	if mulInt(x.N, y.D).Cmp(mulInt(y.N, x.D)) >= 0 {
+		return a
+	}
+	return b
+}
+
+// Вид значения динамического терма (DECISION-0252 п. 5): `r` Rational, `d` Decimal.
+func kindOf(v Val) string {
+	if isRat(v) {
+		return "r"
+	}
+	return "d"
+}
+
+// Статический вид плана → вид значения; `n` — Decimal либо Rational по классу.
+func resolveKind(v Val, k string) string {
+	if k == "n" {
+		k = kindOf(v)
+	}
+	_, isM := v.(Money)
+	known := k == "i" || k == "d" || k == "m" || k == "r" || k == "q"
+	if !known || (k == "r") != isRat(v) || (k == "m") != isM || (k == "q") != isQty(v) {
+		refuse("вид операнда расходится с планом: " + k)
+	}
+	return k
+}
+
+// Целое значение операнда вида Integer: мантисса без масштаба (деление вниз).
+func intOf(v Val) *big.Int {
+	d := v.(Dec)
+	return new(big.Int).Div(d.U, p10(d.S))
+}
+
+// Таблица §58 `values.binary` по видам операндов (DECISION-0252 п. 3–4).
+//
+// Виды — из плана: `i` Integer, `d` Decimal, `m` Money, `r` Rational, `q`
+// Quantity (DECISION-0256), `n` — Decimal либо Rational по значению. Integer
+// и Decimal рантайм по значению не различает, поэтому пара решается видами,
+// а не классами. Ошибка значения — termError с кодом оракула, в его порядке проверок.
+func boundedCoefficient(u *big.Int, s int) {
+	limit := new(big.Int).Lsh(big.NewInt(1), 127)
+	if u.Cmp(new(big.Int).Neg(limit)) < 0 || u.Cmp(new(big.Int).Lsh(big.NewInt(1), 127)) >= 0 || (u.Sign() != 0 && s > 4096) {
+		refuse("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+	}
+}
+func arith(op string, a, b Val, lk, rk string) Val {
+	for _, v := range []Val{a, b} {
+		if u, s, _, _, ok := scaled(v); ok {
+			boundedCoefficient(u, s)
+		}
+	}
+	out := arithUnchecked(op, a, b, lk, rk)
+	if u, s, _, _, ok := scaled(out); ok {
+		boundedCoefficient(u, s)
+		if lk == "i" && rk == "i" && (op == "add" || op == "sub" || op == "mul" || op == "mod") && !u.IsInt64() {
+			refuse("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+		}
+	}
+	return out
+}
+
+func arithUnchecked(op string, a, b Val, lk, rk string) Val {
+	l, r := resolveKind(a, lk), resolveKind(b, rk)
+	has := func(k string) bool { return l == k || r == k }
+	switch op {
+	case "add", "sub":
+		if l == "m" && r == "m" && a.(Money).Cur != b.(Money).Cur {
+			panic(termError{"CURRENCY_MISMATCH"})
+		}
+		if l == "q" && r == "q" && a.(Qty).Unit != b.(Qty).Unit {
+			panic(termError{"DIMENSION_MISMATCH"}) // §49, T023
+		}
+		if l != r {
+			panic(termError{"TYPE_ERROR"})
+		}
+		if l == "r" {
+			return ratPair(a, b, op)
+		}
+		if op == "add" {
+			return add(a, b)
+		}
+		return sub(a, b)
+	case "mul":
+		if (l == "i" && r == "i") || (has("i") && (has("m") || has("d") || has("q"))) {
+			return mul(a, b)
+		}
+		if has("i") && has("r") {
+			q, k := a, b
+			if l != "r" {
+				q, k = b, a
+			}
+			qr := q.(Rational)
+			return newRat(mulInt(qr.N, intOf(k)), qr.D)
+		}
+		if has("i") {
+			panic(termError{"TYPE_ERROR"})
+		}
+		if l == "r" && r == "r" {
+			x, y := a.(Rational), b.(Rational)
+			return newRat(mulInt(x.N, y.N), mulInt(x.D, y.D))
+		}
+		if has("m") && has("r") {
+			// E-0085: доля масштабирует деньги точно; 10-гладкость — после сокращения.
+			m, q := a, b
+			if l != "m" {
+				m, q = b, a
+			}
+			mm, qr := m.(Money), q.(Rational)
+			u, s, ok := exact(mulInt(mm.U, qr.N), mulInt(p10(mm.S), qr.D))
+			if !ok {
+				panic(termError{"INEXACT_DIVISION"})
+			}
+			return Money{U: u, S: s, Cur: mm.Cur}
+		}
+		if has("r") || (l == "m" && r == "m") || (l == "q" && r == "q") || (has("m") && has("q")) {
+			panic(termError{"TYPE_ERROR"})
+		}
+		return mul(a, b)
+	case "div":
+		if l == "r" && r == "r" {
+			x, y := a.(Rational), b.(Rational)
+			if y.N.Sign() == 0 {
+				panic(termError{"DIVISION_BY_ZERO"})
+			}
+			return newRat(mulInt(x.N, y.D), mulInt(x.D, y.N))
+		}
+		if l == "i" && r == "i" {
+			y := intOf(b)
+			if y.Sign() == 0 {
+				panic(termError{"DIVISION_BY_ZERO"})
+			}
+			return newRat(intOf(a), y)
+		}
+		if has("r") {
+			panic(termError{"TYPE_ERROR"})
+		}
+		au, as, _, _, _ := scaled(a)
+		bu, bs, _, _, _ := scaled(b)
+		num, den := mulInt(au, p10(bs)), mulInt(bu, p10(as))
+		if l == "m" && r == "m" {
+			// E-0083: частное сумм одной валюты безразмерно — Decimal либо Rational.
+			if a.(Money).Cur != b.(Money).Cur {
+				panic(termError{"CURRENCY_MISMATCH"})
+			}
+			if bu.Sign() == 0 {
+				panic(termError{"DIVISION_BY_ZERO"})
+			}
+			if u, s, ok := exact(num, den); ok {
+				return Dec{U: u, S: s}
+			}
+			return newRat(num, den)
+		}
+		if l == "q" && r == "q" {
+			// E-0068: частное одной единицы безразмерно; разные единицы — TYPE_ERROR раньше нуля.
+			if a.(Qty).Unit != b.(Qty).Unit {
+				panic(termError{"TYPE_ERROR"})
+			}
+			if bu.Sign() == 0 {
+				panic(termError{"DIVISION_BY_ZERO"})
+			}
+			if u, s, ok := exact(num, den); ok {
+				return Dec{U: u, S: s}
+			}
+			return newRat(num, den)
+		}
+		if !((l == "d" && r == "d") || (l == "m" && r == "d") || (l == "q" && r == "d")) {
+			panic(termError{"TYPE_ERROR"})
+		}
+		if bu.Sign() == 0 {
+			panic(termError{"DIVISION_BY_ZERO"})
+		}
+		if u, s, ok := exact(num, den); ok {
+			return mk(u, s, a)
+		}
+		if l == "d" {
+			return newRat(num, den)
+		}
+		panic(termError{"INEXACT_DIVISION"})
+	case "mod":
+		if l == "i" && r == "i" {
+			y := intOf(b)
+			if y.Sign() == 0 {
+				panic(termError{"DIVISION_BY_ZERO"})
+			}
+			return Dec{U: new(big.Int).Mod(intOf(a), new(big.Int).Abs(y)), S: 0}
+		}
+		panic(termError{"TYPE_ERROR"})
+	}
+	refuse("операция вне среза рантайма: " + op)
+	return nil
+}
+
+func min(a, b Val) Val {
+	if isRat(a) || isRat(b) {
+		return ratPair(a, b, "min")
+	}
+	same(a, b, "min")
+	x, y, _ := pair(a, b)
+	if x.Cmp(y) <= 0 {
+		return a
+	}
+	return b
+}
+
+func max(a, b Val) Val {
+	if isRat(a) || isRat(b) {
+		return ratPair(a, b, "max")
+	}
+	same(a, b, "max")
+	x, y, _ := pair(a, b)
+	if x.Cmp(y) >= 0 {
+		return a
+	}
+	return b
+}
+
+func abs(v Val) Val {
+	if u, s, _, _, ok := scaled(v); ok && s == 0 && u.Cmp(i64Min) == 0 {
+		refuse("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+	}
+	if q, isQ := v.(Rational); isQ {
+		return newRat(new(big.Int).Abs(q.N), q.D)
+	}
+	u, s, _, _, ok := scaled(v)
+	if !ok {
+		refuse("§58: abs — не числовой вид")
+	}
+	return mk(new(big.Int).Abs(u), s, v)
+}
+
+var powExpLimit = big.NewInt(4096)
+var powMin = new(big.Int).Neg(new(big.Int).Lsh(big.NewInt(1), 63))
+var powMax = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 63), big.NewInt(1))
+
+// §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+// вычисление, диапазон — часть контракта.
+func pow(base, exp Val) Val {
+	x, xok := integral(base)
+	e, eok := integral(exp)
+	if !xok || !eok {
+		refuse("§58: pow определён только для Integer")
+	}
+	if e.Sign() < 0 {
+		refuse("§58: pow — показатель отрицателен")
+	}
+	if e.Cmp(powExpLimit) > 0 {
+		refuse("RESOURCE_LIMIT: pow — показатель превышает 4096")
+	}
+	r := new(big.Int).Exp(x, e, nil)
+	if r.Cmp(powMin) < 0 || r.Cmp(powMax) > 0 {
+		refuse("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+	}
+	return Dec{U: r, S: 0}
+}
+
+func round(m Val, digits Val, mode string) Val {
+	if mode != "HALF_UP" {
+		refuse("§50: режим округления не реализован: " + mode)
+	}
+	mu, ms, _, _, ok := scaled(m)
+	if !ok {
+		refuse("§50: round — не числовой вид")
+	}
+	du, ds, _, _, dok := scaled(digits)
+	n := 0
+	if dok {
+		n = int(new(big.Int).Div(du, p10(ds)).Int64())
+	}
+	if ms <= n {
+		return mk(new(big.Int).Mul(mu, p10(n-ms)), n, m)
+	}
+	drop := p10(ms - n)
+	a := new(big.Int).Abs(mu)
+	q, r := new(big.Int).QuoRem(a, drop, new(big.Int))
+	if new(big.Int).Mul(r, big.NewInt(2)).Cmp(drop) >= 0 {
+		q.Add(q, big.NewInt(1)) // HALF_UP — от нуля
+	}
+	if mu.Sign() < 0 {
+		q.Neg(q)
+	}
+	return mk(q, n, m)
+}
+
+// --- политика округления §50 (DECISION-0259) ---------------------------------
+
+var roundingModes = []string{"CEILING", "DOWN", "FLOOR", "HALF_DOWN", "HALF_EVEN", "HALF_UP", "UP"}
+var divRoundMaxPrecision = big.NewInt(34)
+
+// Порт `values._round_fraction` на целых: num/den (den > 0) к целому по
+// режиму §50; `2*tail` против знаменателя, ветви в порядке оракула.
+func roundInt(num, den *big.Int, mode string) *big.Int {
+	negative := num.Sign() < 0
+	head, tail := new(big.Int).QuoRem(new(big.Int).Abs(num), den, new(big.Int))
+	c := new(big.Int).Lsh(tail, 1).Cmp(den)
+	up := false
+	switch mode {
+	case "HALF_UP":
+		up = c >= 0
+	case "HALF_EVEN":
+		up = c > 0 || (c == 0 && head.Bit(0) == 1)
+	case "HALF_DOWN":
+		up = c > 0
+	case "UP":
+		up = tail.Sign() > 0
+	case "DOWN":
+		up = false
+	case "CEILING":
+		up = tail.Sign() > 0 && !negative
+	case "FLOOR":
+		up = tail.Sign() > 0 && negative
+	default:
+		refuse("§50: режим округления вне семи: " + mode)
+	}
+	if up {
+		head.Add(head, big.NewInt(1))
+	}
+	if negative {
+		head.Neg(head)
+	}
+	return head
+}
+
+// Точность политики: Integer либо целый Decimal, вид — из плана. Дробная
+// точность — TYPE_ERROR; проверка на целом произвольной длины до перевода в int.
+func policyScale(p Val, pk string) *big.Int {
+	if pk != "i" && pk != "d" {
+		refuse("вид точности расходится с планом: " + pk)
+	}
+	resolveKind(p, pk)
+	d, ok := p.(Dec)
+	if !ok {
+		refuse("вид операнда расходится с планом: " + pk)
+	}
+	q, r := new(big.Int).QuoRem(d.U, p10(d.S), new(big.Int))
+	if r.Sign() != 0 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return q
+}
+
+// Режим политики: Text, один из семи §50; иное — TYPE_ERROR.
+func policyMode(mode Val) string {
+	s, ok := mode.(string)
+	if ok {
+		for _, m := range roundingModes {
+			if m == s {
+				return s
+			}
+		}
+	}
+	panic(termError{"TYPE_ERROR"})
+}
+
+// §50 `round` с проверкой политики (DECISION-0259 п. 4, 7): порядок
+// `values.round_value` — вид, точность (целое >= 0), режим. Integer — тождество
+// (E-0110); точность не короче дробной части — значение то же (E-0184).
+func roundMode(v, p, mode Val, vk, pk string) Val {
+	k := resolveKind(v, vk)
+	if k == "r" {
+		panic(termError{"TYPE_ERROR"})
+	}
+	scale := policyScale(p, pk)
+	if scale.Sign() < 0 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	m := policyMode(mode)
+	u, s, _, _, _ := scaled(v)
+	if k == "i" || scale.Cmp(big.NewInt(int64(s))) >= 0 {
+		return v
+	}
+	n := int(scale.Int64()) // scale < s: помещается в int
+	return mk(roundInt(u, p10(s-n), m), n, v)
+}
+
+// §50/§58 `div_round` (E-0036, E-0170; DECISION-0259 п. 4, 7): пара →
+// валюта → ноль → точность 0..34 → режим. Частное точное, округление всегда;
+// Money/Money — доля Decimal без тега.
+func divRound(a, b, p, mode Val, ak, bk, pk string) Val {
+	l, r := resolveKind(a, ak), resolveKind(b, bk)
+	if !((l == "m" && r == "d") || (l == "q" && r == "d") || (l == "d" && r == "d") || (l == "m" && r == "m")) {
+		panic(termError{"TYPE_ERROR"})
+	}
+	if l == "m" && r == "m" && a.(Money).Cur != b.(Money).Cur {
+		panic(termError{"CURRENCY_MISMATCH"})
+	}
+	au, as, _, _, _ := scaled(a)
+	bu, bs, _, _, _ := scaled(b)
+	if bu.Sign() == 0 {
+		panic(termError{"DIVISION_BY_ZERO"})
+	}
+	scale := policyScale(p, pk)
+	if scale.Sign() < 0 || scale.Cmp(divRoundMaxPrecision) > 0 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	m := policyMode(mode)
+	n := int(scale.Int64())
+	num, den := mulInt(au, p10(bs+n)), mulInt(bu, p10(as))
+	if den.Sign() < 0 {
+		num.Neg(num)
+		den.Neg(den)
+	}
+	q := roundInt(num, den, m)
+	if r == "m" {
+		return Dec{U: q, S: n}
+	}
+	return mk(q, n, a)
+}
+
+// --- сравнение и равенство ---------------------------------------------------
+
+func cmp(a Val, op string, b Val) bool {
+	if ab, aok := a.(bool); aok || isBool(b) {
+		// §57 (DECISION-0266): Boolean сравнимо только на равенство и только с Boolean.
+		bb, bok := b.(bool)
+		sameBool := aok && bok && ab == bb
+		switch op {
+		case "eq":
+			return sameBool
+		case "ne":
+			return !sameBool
+		}
+		refuse("§57: вид Boolean не упорядочен")
+	}
+	if isRat(a) || isRat(b) {
+		// §57/§48 (DECISION-0252 п. 6): Rational сравнивается только с Rational;
+		// иной вид — TYPE_ERROR оракула, а не false.
+		x, xok := a.(Rational)
+		y, yok := b.(Rational)
+		if !xok || !yok {
+			panic(termError{"TYPE_ERROR"})
+		}
+		c := mulInt(x.N, y.D).Cmp(mulInt(y.N, x.D))
+		switch op {
+		case "lt":
+			return c < 0
+		case "le":
+			return c <= 0
+		case "gt":
+			return c > 0
+		case "ge":
+			return c >= 0
+		case "eq":
+			return c == 0
+		case "ne":
+			return c != 0
+		}
+		refuse("сравнение вне среза рантайма: " + op)
+	}
+	if isQty(a) || isQty(b) {
+		// §49/§57 (DECISION-0256 п. 5): величина — только с величиной той же единицы.
+		same(a, b, "cmp")
+		x, y, _ := pair(a, b)
+		c := x.Cmp(y)
+		switch op {
+		case "lt":
+			return c < 0
+		case "le":
+			return c <= 0
+		case "gt":
+			return c > 0
+		case "ge":
+			return c >= 0
+		case "eq":
+			return c == 0
+		case "ne":
+			return c != 0
+		}
+		refuse("сравнение вне среза рантайма: " + op)
+	}
+	asym, asok := a.(Sym)
+	bsym, bsok := b.(Sym)
+	if asok || bsok {
+		sameSym := asok && bsok && asym == bsym
+		switch op {
+		case "eq":
+			return sameSym
+		case "ne":
+			return !sameSym
+		}
+		refuse("§57: вид enum не упорядочен")
+	}
+	ai, aiok := a.(Instant)
+	bi, biok := b.(Instant)
+	if aiok || biok {
+		if aiok && biok {
+			c := momentCmp(ai, bi)
+			switch op {
+			case "lt":
+				return c < 0
+			case "le":
+				return c <= 0
+			case "gt":
+				return c > 0
+			case "ge":
+				return c >= 0
+			case "eq":
+				return c == 0
+			case "ne":
+				return c != 0
+			}
+			refuse("сравнение вне среза рантайма: " + op)
+		}
+		// §57/§2.15: Date и Instant не сравниваются (DATE_INSTANT_MISMATCH оракула).
+		refuse("§57: Instant сравнивается только с Instant")
+	}
+	ad, adok := a.(Date)
+	bd, bdok := b.(Date)
+	if adok || bdok {
+		if adok && bdok {
+			switch op {
+			case "lt":
+				return ad < bd
+			case "le":
+				return ad <= bd
+			case "gt":
+				return ad > bd
+			case "ge":
+				return ad >= bd
+			case "eq":
+				return ad == bd
+			case "ne":
+				return ad != bd
+			}
+			refuse("сравнение вне среза рантайма: " + op)
+		}
+		switch op {
+		case "eq":
+			return false
+		case "ne":
+			return true
+		}
+		refuse("§57: Date сравнивается только с Date")
+	}
+	as, aok := a.(string)
+	bs, bok := b.(string)
+	if aok || bok {
+		switch op {
+		case "eq":
+			return aok && bok && as == bs
+		case "ne":
+			return !(aok && bok && as == bs)
+		}
+		refuse("порядок на Text вне среза рантайма: " + op)
+	}
+	_, _, acur, amoney, _ := scaled(a)
+	_, _, bcur, bmoney, _ := scaled(b)
+	if amoney != bmoney {
+		refuse("§49: сравнение денег с безразмерным")
+	}
+	if amoney && acur != bcur {
+		refuse("§49: разные валюты")
+	}
+	x, y, _ := pair(a, b)
+	c := x.Cmp(y)
+	switch op {
+	case "lt":
+		return c < 0
+	case "le":
+		return c <= 0
+	case "gt":
+		return c > 0
+	case "ge":
+		return c >= 0
+	case "eq":
+		return c == 0
+	case "ne":
+		return c != 0
+	}
+	refuse("сравнение вне среза рантайма: " + op)
+	return false
+}
+
+func isBool(v Val) bool {
+	_, ok := v.(bool)
+	return ok
+}
+
+func eq(a, b Val) bool {
+	if isBool(a) || isBool(b) {
+		// DECISION-0266: Boolean равен только Boolean того же значения.
+		x, xok := a.(bool)
+		y, yok := b.(bool)
+		return xok && yok && x == y
+	}
+	if isRat(a) || isRat(b) {
+		x, xok := a.(Rational)
+		y, yok := b.(Rational)
+		return xok && yok && x.N.Cmp(y.N) == 0 && x.D.Cmp(y.D) == 0
+	}
+	if isQty(a) || isQty(b) {
+		x, xok := a.(Qty)
+		y, yok := b.(Qty)
+		if !xok || !yok || x.Unit != y.Unit {
+			return false
+		}
+		u, w, _ := pair(a, b)
+		return u.Cmp(w) == 0
+	}
+	asym, asok := a.(Sym)
+	bsym, bsok := b.(Sym)
+	if asok || bsok {
+		return asok && bsok && asym == bsym
+	}
+	ad, adok := a.(Date)
+	bd, bdok := b.(Date)
+	if adok || bdok {
+		return adok && bdok && ad == bd
+	}
+	ai, aiok := a.(Instant)
+	bi, biok := b.(Instant)
+	if aiok || biok {
+		if !aiok || !biok {
+			return false
+		}
+		return momentCmp(ai, bi) == 0
+	}
+	as, aok := a.(string)
+	bs, bok := b.(string)
+	if aok || bok {
+		return aok && bok && as == bs
+	}
+	_, _, acur, amoney, _ := scaled(a)
+	_, _, bcur, bmoney, _ := scaled(b)
+	if amoney != bmoney || acur != bcur {
+		return false
+	}
+	x, y, _ := pair(a, b)
+	return x.Cmp(y) == 0
+}
+
+func norm(u *big.Int, s int) string {
+	if u.Sign() == 0 {
+		return "0e-0"
+	}
+	v := new(big.Int).Set(u)
+	ten := big.NewInt(10)
+	for s > 0 && new(big.Int).Mod(v, ten).Sign() == 0 {
+		v.Div(v, ten)
+		s--
+	}
+	return fmt.Sprintf("%se-%d", v.String(), s)
+}
+
+// Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+// ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+var keyEscaper = strings.NewReplacer(`\`, `\\`, `|`, `\|`)
+
+func key(row []Val) string {
+	parts := make([]string, len(row))
+	for i, v := range row {
+		switch x := v.(type) {
+		case string:
+			parts[i] = "e:" + keyEscaper.Replace(x)
+		case bool:
+			if x {
+				parts[i] = "b:true"
+			} else {
+				parts[i] = "b:false"
+			}
+		case Date:
+			parts[i] = "t:" + string(x)
+		case Instant:
+			parts[i] = "i:" + keyEscaper.Replace(string(x))
+		case Sym:
+			parts[i] = "c:" + keyEscaper.Replace(string(x))
+		case Rational:
+			parts[i] = "r:" + x.N.String() + "/" + x.D.String()
+		case Qty:
+			// DECISION-0256 п. 5: тег экранируется, как текст; вид отличен от денег.
+			parts[i] = "q:" + keyEscaper.Replace(x.Unit) + ":" + norm(x.U, x.S)
+		case Money:
+			parts[i] = "m:" + x.Cur + ":" + norm(x.U, x.S)
+		case Dec:
+			parts[i] = "d:" + norm(x.U, x.S)
+		}
+	}
+	return strings.Join(parts, "|")
+}
+
+// evalContext — контекст одного вычисления (DECISION-0423 §2.3): правовое время
+// дела, политика срока §86 и снимок календаря §85. Каждый экземпляр модели
+// (`newModel`) держит свой контекст; порождённые правила видят его функции через
+// локальные замыкания фабрики, поэтому параллельные вычисления его не делят.
+type evalContext struct {
+	lt       string
+	policy   map[string]interface{}
+	snapshot *Snapshot
+}
+
+func (c *evalContext) setLegalTime(t string) { c.lt = t }
+
+func (c *evalContext) legalTime() string {
+	if c.lt == "" {
+		refuse("legalTime не подан делом")
+	}
+	return c.lt
+}
+
+// --- календарь §84–§86 (DECISION-0245) ---------------------------------------
+// Порт `lawref.values` и `lawref.calendar` дословно по порядку проверок: код
+// ошибки — часть ответа (issue модели).
+
+type termError struct{ code string }
+
+// Снимок §85 плана: датасет либо код ошибки загрузки.
+type Snapshot struct {
+	ID           string          `json:"id"`
+	Error        string          `json:"error"`
+	Start        string          `json:"start"`
+	EndExclusive string          `json:"endExclusive"`
+	Weekly       []bool          `json:"weekly"`
+	Overrides    map[string]bool `json:"overrides"`
+}
+
+func (c *evalContext) setCalendar(policy map[string]interface{}, snapshot *Snapshot) {
+	c.policy, c.snapshot = policy, snapshot
+}
+
+// Литерал плана JSON-строкой: политики, снимки, правила обхода E-0105.
+func planJSON(text string) interface{} {
+	d := json.NewDecoder(strings.NewReader(text))
+	d.UseNumber()
+	var v interface{}
+	if err := d.Decode(&v); err != nil {
+		panic(err)
+	}
+	return v
+}
+
+func dayOf8(day string) time.Time {
+	t, err := time.Parse("2006-01-02", day)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+func plusDays(day string, n int) string { return dayOf8(day).AddDate(0, 0, n).Format("2006-01-02") }
+
+func (c *evalContext) calendarLoaded() *Snapshot {
+	if c.snapshot == nil || c.snapshot.Error == "MISSING_CALENDAR" {
+		panic(termError{"MISSING_CALENDAR"})
+	}
+	if c.snapshot.Error != "" {
+		panic(termError{c.snapshot.Error})
+	}
+	return c.snapshot
+}
+
+func coverage(cal *Snapshot, day string) {
+	if !(cal.Start <= day && day < cal.EndExclusive) {
+		panic(termError{"CALENDAR_OUT_OF_RANGE"})
+	}
+}
+
+func working(cal *Snapshot, day string) bool {
+	coverage(cal, day)
+	if o, ok := cal.Overrides[day]; ok {
+		return o
+	}
+	return cal.Weekly[(int(dayOf8(day).Weekday())+6)%7]
+}
+
+func previousWorking(cal *Snapshot, day string) string {
+	coverage(cal, day)
+	current := plusDays(day, -1)
+	for {
+		coverage(cal, current)
+		if working(cal, current) {
+			return current
+		}
+		current = plusDays(current, -1)
+	}
+}
+
+func nextWorking(cal *Snapshot, day string) string {
+	for !working(cal, day) {
+		day = plusDays(day, 1)
+		coverage(cal, day)
+	}
+	return day
+}
+
+func addMonths(day string, months int, monthEnd string) string {
+	t := dayOf8(day)
+	total := int(t.Month()) - 1 + months
+	year := t.Year() + floorDiv(total, 12)
+	month := ((total%12)+12)%12 + 1
+	last := time.Date(year, time.Month(month)+1, 0, 0, 0, 0, 0, time.UTC).Day()
+	if t.Day() <= last {
+		return time.Date(year, time.Month(month), t.Day(), 0, 0, 0, 0, time.UTC).Format("2006-01-02")
+	}
+	if monthEnd == "last_day_of_month" {
+		return time.Date(year, time.Month(month), last, 0, 0, 0, 0, time.UTC).Format("2006-01-02")
+	}
+	panic(termError{"DEADLINE_POLICY_INVALID"})
+}
+
+func floorDiv(a, b int) int {
+	q := a / b
+	if (a%b != 0) && ((a < 0) != (b < 0)) {
+		q--
+	}
+	return q
+}
+
+func calUnit(unit string) bool  { return unit == "calendar_month" || unit == "calendar_year" }
+func stepUnit(unit string) bool { return calUnit(unit) || unit == "calendar_week" }
+func policyStr(p map[string]interface{}, k string) (string, bool, bool) {
+	v, present := p[k]
+	if !present || v == nil {
+		return "", false, true
+	}
+	s, ok := v.(string)
+	return s, true, ok
+}
+
+func needsCalendar(unit string, policy map[string]interface{}) bool {
+	if !stepUnit(unit) {
+		return true
+	}
+	roll, _, _ := policyStr(policy, "roll")
+	include, isBool := policy["include_end"].(bool)
+	return roll != "no_roll" || !isBool || !include
+}
+
+// Порт `calendar.compute_deadline` без приостановлений (терм их не несёт).
+func deadlineDue(cal *Snapshot, after string, count int, policy map[string]interface{}, afterTime *string,
+	unit string, calendarDayStep bool) string {
+	if policy == nil {
+		panic(termError{"MISSING_POLICY"})
+	}
+	for k := range policy {
+		switch k {
+		case "start_count", "include_end", "roll", "cutoff", "month_end":
+		default:
+			panic(termError{"DEADLINE_POLICY_INVALID"})
+		}
+	}
+	startCount, _, scOk := policyStr(policy, "start_count")
+	roll, _, rollOk := policyStr(policy, "roll")
+	includeEnd, ieOk := policy["include_end"].(bool)
+	cutoff, hasCutoff, cutoffOk := policyStr(policy, "cutoff")
+	if !scOk || (startCount != "same_day" && startCount != "next_day") || !rollOk ||
+		(roll != "no_roll" && roll != "next_working_day" && roll != "previous_working_day") || !ieOk || !cutoffOk {
+		panic(termError{"DEADLINE_POLICY_INVALID"})
+	}
+	if count < 0 {
+		panic(termError{"DEADLINE_POLICY_INVALID"})
+	}
+	monthEnd, hasMonthEnd, meOk := policyStr(policy, "month_end")
+	if calUnit(unit) {
+		if !hasMonthEnd || !meOk || (monthEnd != "last_day_of_month" && monthEnd != "reject_nonexistent") {
+			panic(termError{"DEADLINE_POLICY_INVALID"})
+		}
+	} else if hasMonthEnd && (!meOk || (monthEnd != "last_day_of_month" && monthEnd != "reject_nonexistent")) {
+		panic(termError{"DEADLINE_POLICY_INVALID"})
+	}
+	start := after
+	wants := !calendarDayStep && needsCalendar(unit, policy)
+	if wants {
+		coverage(cal, start)
+	}
+	if hasCutoff && afterTime != nil && *afterTime > cutoff {
+		start = plusDays(start, 1)
+		if wants {
+			coverage(cal, start)
+		}
+	}
+	if startCount == "next_day" {
+		start = plusDays(start, 1)
+		if wants {
+			coverage(cal, start)
+		}
+	}
+	due := start
+	if calUnit(unit) {
+		months := count
+		if unit == "calendar_year" {
+			months = count * 12
+		}
+		if count > 0 {
+			due = addMonths(start, months, monthEnd)
+		}
+		if count > 0 && !includeEnd {
+			coverage(cal, due)
+			due = previousWorking(cal, due)
+		}
+	} else if calendarDayStep || unit == "calendar_week" {
+		multiplier := 7
+		if calendarDayStep {
+			multiplier = 1
+		}
+		if count > 0 {
+			due = plusDays(start, multiplier*count)
+		}
+		if count > 0 && !includeEnd {
+			coverage(cal, due)
+			due = previousWorking(cal, due)
+		}
+	} else if count > 0 {
+		counted := 0
+		for {
+			coverage(cal, due)
+			if unit != "business_day" || working(cal, due) {
+				counted++
+				if counted == count {
+					break
+				}
+			}
+			due = plusDays(due, 1)
+		}
+		if !includeEnd {
+			due = previousWorking(cal, due)
+		}
+	}
+	skipRoll := (calendarDayStep || stepUnit(unit)) && roll == "no_roll"
+	if !skipRoll && !working(cal, due) && roll != "no_roll" {
+		if roll == "next_working_day" {
+			due = nextWorking(cal, due)
+		} else {
+			due = previousWorking(cal, due)
+		}
+	}
+	return due
+}
+
+// §84.2 (E-0084, DECISION-0267): границы месяца — чистые функции над Date; ни
+// политика §86, ни снимок §85 не читаются (`values.month_bound_value`).
+func monthParts(d Val) (int, time.Month, int) {
+	day, ok := d.(Date)
+	if !ok || len(string(day)) != 10 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	t, err := time.Parse("2006-01-02", string(day))
+	if err != nil {
+		panic(termError{"TYPE_ERROR"})
+	}
+	last := time.Date(t.Year(), t.Month()+1, 0, 0, 0, 0, 0, time.UTC).Day()
+	return t.Year(), t.Month(), last
+}
+
+func month_start(d Val) Date {
+	y, m, _ := monthParts(d)
+	return Date(fmt.Sprintf("%04d-%02d-01", y, int(m)))
+}
+
+func month_end(d Val) Date {
+	y, m, last := monthParts(d)
+	return Date(fmt.Sprintf("%04d-%02d-%02d", y, int(m), last))
+}
+
+// §84.1 (E-0028/E-0058; W2 часть 2): полных единиц между мгновениями, знак сохранён, дробь к нулю.
+func durationBetween(a, b Val, unit int64, where string) Dec {
+	ai, aok := a.(Instant)
+	bi, bok := b.(Instant)
+	if !aok || !bok {
+		panic(termError{"TYPE_ERROR"})
+	}
+	x, y := exactMoment(ai), exactMoment(bi)
+	seconds := y.seconds - x.seconds
+	if seconds > 0 && y.fraction < x.fraction {
+		seconds--
+	} else if seconds < 0 && y.fraction > x.fraction {
+		seconds++
+	}
+
+	var units int64
+	if seconds >= 0 {
+		units = seconds / unit
+	} else {
+		units = -((-seconds) / unit)
+	}
+	return Dec{big.NewInt(units), 0}
+}
+
+func hours_between(a, b Val) Dec   { return durationBetween(a, b, 3600, "hours_between") }
+func minutes_between(a, b Val) Dec { return durationBetween(a, b, 60, "minutes_between") }
+
+var durationSeconds = map[string]int64{"second": 1, "minute": 60, "hour": 3600, "day": 86400}
+
+// §84.1 (E-0185): мгновение через целую Quantity секунд/минут/часов/суток; канон UTC без дробных секунд.
+func add_duration(after Val, count int, unit string) Instant {
+	ai, ok := after.(Instant)
+	factor, unitOk := durationSeconds[unit]
+	if !ok || !unitOk {
+		panic(termError{"TYPE_ERROR"})
+	}
+	x := exactMoment(ai)
+	delta := new(big.Int).Mul(big.NewInt(int64(count)), big.NewInt(factor))
+	total := new(big.Int).Add(big.NewInt(x.seconds), delta)
+	if !total.IsInt64() {
+		panic(termError{"RESOURCE_LIMIT"})
+	}
+	result := time.Unix(total.Int64(), 0).UTC()
+	if result.Year() < 1 || result.Year() > 9999 {
+		panic(termError{"RESOURCE_LIMIT"})
+	}
+
+	return Instant(result.Format("2006-01-02T15:04:05Z"))
+}
+
+// §84.4 (E-0015): календарные дни от `a` до `b`, со знаком.
+func days_between(a, b Date) Dec {
+	days := int64(dayOf8(string(b)).Sub(dayOf8(string(a))).Hours() / 24)
+	return Dec{big.NewInt(days), 0}
+}
+
+// §84.2 (E-0029): `TermEnv.calendar_period` — снимок не читается.
+func (c *evalContext) add_calendar_period(after Date, count int, unit string) Date {
+	p := c.policy
+	if p == nil {
+		p = map[string]interface{}{}
+	}
+	roll, hasRoll, _ := policyStr(p, "roll")
+	_, hasCutoff, _ := policyStr(p, "cutoff")
+	include, isBool := p["include_end"].(bool)
+	if (hasRoll && roll != "no_roll") || hasCutoff || !isBool || !include {
+		panic(termError{"MISSING_POLICY"})
+	}
+	return Date(deadlineDue(nil, string(after), count, p, nil, unit, unit == "calendar_day"))
+}
+
+// Единицы счётчика-связывателя по функции (E-0029/E-0109).
+var counterUnits = map[string][]string{
+	"add_business_days":   {"business_day", "calendar_day"},
+	"add_calendar_period": {"calendar_day", "calendar_month", "calendar_year", "calendar_week"},
+	"add_legal_term":      {"business_day", "calendar_day", "calendar_month", "calendar_year", "calendar_week"},
+}
+
+// §86.1 (DECISION-0256 п. 6): счётчик-связыватель — Quantity с единицей,
+// допустимой функции, целый; иначе TYPE_ERROR (`values.add_*_value`). Знак не
+// проверяется: отрицательный счётчик отвергает сама операция политикой §86.
+func counter(v Val, fn string) (int, string) {
+	q, ok := v.(Qty)
+	if !ok {
+		panic(termError{"TYPE_ERROR"})
+	}
+	allowed := false
+	for _, u := range counterUnits[fn] {
+		if u == q.Unit {
+			allowed = true
+		}
+	}
+	whole, rest := new(big.Int).QuoRem(q.U, p10(q.S), new(big.Int))
+	if !allowed || rest.Sign() != 0 {
+		panic(termError{"TYPE_ERROR"})
+	}
+	return int(whole.Int64()), q.Unit
+}
+
+// §86.1: ветвь по единице на деле — рабочий счёт либо календарный шаг.
+func (c *evalContext) add_legal_term(after Date, count int, unit string) Date {
+	if unit == "business_day" || unit == "calendar_day" {
+		return c.add_business_days(after, count, unit)
+	}
+	return c.add_calendar_period(after, count, unit)
+}
+
+// §86: `TermEnv.deadline` — политика, затем снимок, если срок его спрашивает.
+func (c *evalContext) add_business_days(after Date, count int, unit string, afterTime ...Val) Date {
+	if c.policy != nil {
+		if _, hasCutoff, _ := policyStr(c.policy, "cutoff"); hasCutoff && len(afterTime) == 0 {
+			panic(termError{"MISSING_POLICY"})
+		}
+	}
+	var cal *Snapshot
+	if needsCalendar(unit, c.policy) {
+		cal = c.calendarLoaded()
+	}
+	var at *string
+	if len(afterTime) == 1 {
+		s := fmt.Sprint(afterTime[0])
+		at = &s
+	}
+	return Date(deadlineDue(cal, string(after), count, c.policy, at, unit, false))
+}
+
+// Поимка ошибки календаря в гарде, голове и границе окна (DECISION-0245 п. 6, 8).
+func tryBool(f func() bool) (ok bool, code string) {
+	defer func() {
+		if rec := recover(); rec != nil {
+			if e, isT := rec.(termError); isT {
+				code = e.code
+				return
+			}
+			panic(rec)
+		}
+	}()
+	return f(), ""
+}
+
+func tryRow(f func() []Val) (row []Val, code string) {
+	defer func() {
+		if rec := recover(); rec != nil {
+			if e, isT := rec.(termError); isT {
+				code = e.code
+				return
+			}
+			panic(rec)
+		}
+	}()
+	return f(), ""
+}
+
+func planSnapshots(text string) []Snapshot {
+	var out []Snapshot
+	if err := json.Unmarshal([]byte(text), &out); err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// ---------------------------------------------------------------------------
+// §47.3 Канал суждения (DECISION-0274): порт `whynot.judgment_blockers`,
+// `defeater_judgment_blockers`, `power_judgment_blockers` и
+// `position_judgment_blockers` над ГОТОВЫМ состоянием модели. Один код для
+// раннера и API; модель отдаёт состояние функциями-доступами (judgmentDecls,
+// backchainEnv, truthOf, appliedCands, supportBits, prioHas, judgmentPositions,
+// blockedImmunity), переводы термов приходят в jHooks. Запрос называет судью
+// только там, где его ответ может изменить исход: живость правила по
+// конъюнктам (E-0101), по поражению вывода (E-0103), по способности дефитера
+// снять вывод (E-0100), по иммунитету (E-0120); порядок запросов —
+// канонические байты объекта `request` (E-0111).
+
+type judgmentDecl struct {
+	Authority     string
+	RequestSchema interface{} // nil — форма запроса не объявлена
+}
+
+type appliedCand struct {
+	rule     string
+	defeater bool
+	urn      string
+	positive bool
+	key      string
+	defeated bool
+}
+
+type jLit struct {
+	pred     string
+	positive bool
+	row      []Val
+}
+
+type jPos struct {
+	modality, status, rule            string
+	exercise, validWhen, effect, cond *jLit
+}
+
+// Доступы модели для обхода: печатает порождённая модель (`judgmentModel()`).
+type jModel struct {
+	truth           func(urn string, row []Val) string
+	tables          func() map[string][][]Val
+	backchain       func() ([]interface{}, map[string]interface{})
+	decls           func() map[string]judgmentDecl
+	applied         func() []appliedCand
+	supportBits     func(urn string, row []Val) int
+	prioHas         func(a, b string) bool
+	positions       func() []jPos
+	blockedImmunity func(pred string, row []Val) bool
+	legalTime       func() string // правовое время вычисления (DECISION-0423 §2.3)
+}
+
+type jHooks struct {
+	val  func(map[string]interface{}) Val                         // литерал-терм §53 → значение
+	cell func(pred string, col int, v Val) map[string]interface{} // ячейка таблицы → литерал-терм
+}
+
+const judgmentEnumCap = 8
+
+var jTestable = map[string]bool{"established": true, "supported": true, "monotone": true, "refuted": true}
+var jMirror = map[string]string{"TRUE_ONLY": "FALSE_ONLY", "FALSE_ONLY": "TRUE_ONLY", "BOTH": "BOTH", "NEITHER": "NEITHER"}
+var jConjunct = map[string]string{"TRUE_ONLY": "SATISFIED", "FALSE_ONLY": "NOT_SATISFIED", "BOTH": "CONFLICTED", "NEITHER": "UNDETERMINED"}
+var jComputed = map[string]bool{"binary": true, "call": true, "if": true, "let": true, "match": true, "aggregate": true}
+
+func jfield(m map[string]interface{}, k string) map[string]interface{} {
+	if m == nil {
+		return nil
+	}
+	if x, ok := m[k].(map[string]interface{}); ok {
+		return x
+	}
+	return nil
+}
+
+func jlist(m map[string]interface{}, k string) []interface{} {
+	if m == nil {
+		return nil
+	}
+	if x, ok := m[k].([]interface{}); ok {
+		return x
+	}
+	return nil
+}
+
+func jstr(v interface{}) string {
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func jstrJSON(s string) string {
+	var b bytes.Buffer
+	enc := json.NewEncoder(&b)
+	enc.SetEscapeHTML(false)
+	_ = enc.Encode(s)
+	return strings.TrimRight(b.String(), "\n")
+}
+
+// Канонические байты §208 объекта запроса: ключи по порядку, целое из JSON — цифрами.
+func jcanon(v interface{}) string {
+	switch x := v.(type) {
+	case nil:
+		return "null"
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case string:
+		return jstrJSON(x)
+	case json.Number:
+		return x.String()
+	case float64:
+		return strconv.FormatFloat(x, 'f', -1, 64)
+	case int:
+		return strconv.Itoa(x)
+	case []interface{}:
+		parts := make([]string, len(x))
+		for i, e := range x {
+			parts[i] = jcanon(e)
+		}
+		return "[" + strings.Join(parts, ",") + "]"
+	case map[string]interface{}:
+		if len(x) == 1 {
+			if n, ok := x["int"]; ok {
+				return jcanon(n)
+			}
+		}
+		keys := make([]string, 0, len(x))
+		for k := range x {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		parts := make([]string, len(keys))
+		for i, k := range keys {
+			parts[i] = jstrJSON(k) + ":" + jcanon(x[k])
+		}
+		return "{" + strings.Join(parts, ",") + "}"
+	}
+	return "null"
+}
+
+func jpolarity(lit map[string]interface{}) string {
+	if p := jstr(lit["polarity"]); p != "" {
+		return p
+	}
+	return "positive"
+}
+
+func requestKey(lit map[string]interface{}) string {
+	args := jlist(lit, "args")
+	if args == nil {
+		args = []interface{}{}
+	}
+	return jcanon(map[string]interface{}{"relation": lit["predicate"], "polarity": jpolarity(lit), "args": args})
+}
+
+func orderRequests(lits []map[string]interface{}) []map[string]interface{} {
+	found := map[string]map[string]interface{}{}
+	keys := []string{}
+	for _, l := range lits {
+		k := requestKey(l)
+		if _, ok := found[k]; !ok {
+			found[k] = l
+			keys = append(keys, k)
+		}
+	}
+	sort.Strings(keys)
+	out := make([]map[string]interface{}, len(keys))
+	for i, k := range keys {
+		out[i] = found[k]
+	}
+	return out
+}
+
+func jtruth(m jModel, h jHooks, lit map[string]interface{}) string {
+	args := jlist(lit, "args")
+	row := make([]Val, len(args))
+	for i, a := range args {
+		row[i] = h.val(a.(map[string]interface{}))
+	}
+	st := m.truth(jstr(lit["predicate"]), row)
+	if jpolarity(lit) == "negative" {
+		return jMirror[st]
+	}
+	return st
+}
+
+func jvars(t interface{}, out map[string]bool) {
+	switch x := t.(type) {
+	case []interface{}:
+		for _, e := range x {
+			jvars(e, out)
+		}
+	case map[string]interface{}:
+		if jstr(x["kind"]) == "var" {
+			out[jstr(x["var"])] = true
+			return
+		}
+		for _, e := range x {
+			jvars(e, out)
+		}
+	}
+}
+
+func junbound(t interface{}, subst map[string]map[string]interface{}) []string {
+	names := map[string]bool{}
+	jvars(t, names)
+	out := []string{}
+	for n := range names {
+		if _, ok := subst[n]; !ok {
+			out = append(out, n)
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+func jkind(name string) string {
+	switch name {
+	case "urn:law:std#Integer", "urn:law:std#Natural":
+		return "i"
+	case "urn:law:std#Decimal":
+		return "d"
+	case "urn:law:std#Money":
+		return "m"
+	case "urn:law:std#Rational":
+		return "r"
+	case "urn:law:std#Quantity":
+		return "q"
+	}
+	return "x"
+}
+
+// Гард §57–§58 под подстановкой: переменные, литералы, константы §54 и
+// арифметика §58; иное — паника, у оракула это UNDETERMINED (E-0101).
+func jterm(m jModel, h jHooks, t map[string]interface{}, subst map[string]map[string]interface{}) (Val, string) {
+	switch jstr(t["kind"]) {
+	case "var":
+		s, ok := subst[jstr(t["var"])]
+		if !ok {
+			panic(Refused("несвязанная переменная гарда"))
+		}
+		return jterm(m, h, s, subst)
+	case "const_ref":
+		if _, consts := m.backchain(); consts != nil {
+			if c, has := consts[jstr(t["id"])].(map[string]interface{}); has {
+				return jterm(m, h, c, subst)
+			}
+		}
+		return h.val(t), "x"
+	case "entity_ref":
+		return h.val(t), "x"
+	case "value":
+		return h.val(t), jkind(jstr(jfield(t, "type")["name"]))
+	case "binary":
+		op := jstr(t["op"])
+		switch op {
+		case "add", "sub", "mul", "div", "mod":
+			lv, lk := jterm(m, h, jfield(t, "left"), subst)
+			rv, rk := jterm(m, h, jfield(t, "right"), subst)
+			if lk == "x" || rk == "x" {
+				panic(Refused("арифметика над нечисловым операндом"))
+			}
+			v := arith(op, lv, rv, lk, rk)
+			switch v.(type) {
+			case Rational:
+				return v, "r"
+			case Money:
+				return v, "m"
+			case Qty:
+				return v, "q"
+			}
+			if lk == "i" && rk == "i" {
+				return v, "i"
+			}
+			return v, "d"
+		}
+	}
+	panic(Refused("терм гарда вне обхода суждения: " + jstr(t["kind"])))
+}
+
+func jguard(m jModel, h jHooks, g map[string]interface{}, subst map[string]map[string]interface{}) (ok bool, failed bool) {
+	defer func() {
+		if r := recover(); r != nil {
+			ok, failed = false, true
+		}
+	}()
+	lv, _ := jterm(m, h, jfield(g, "left"), subst)
+	rv, _ := jterm(m, h, jfield(g, "right"), subst)
+	return cmp(lv, jstr(g["op"]), rv), false
+}
+
+type jReport struct {
+	trigger string
+	ground  map[string]interface{} // nil у гарда, квантора и вычисляемого аргумента
+}
+
+func jsubstArgs(lit map[string]interface{}, subst map[string]map[string]interface{}) map[string]interface{} {
+	args := jlist(lit, "args")
+	out := make([]interface{}, len(args))
+	for i, a := range args {
+		am := a.(map[string]interface{})
+		if jstr(am["kind"]) == "var" {
+			out[i] = subst[jstr(am["var"])]
+		} else {
+			out[i] = am
+		}
+	}
+	shown := map[string]interface{}{}
+	for k, v := range lit {
+		shown[k] = v
+	}
+	shown["args"] = out
+	return shown
+}
+
+// Порт `whynot._conjunct_report`: ok=false — конъюнкт с несвязанной переменной.
+func jconjunct(m jModel, h jHooks, status string, lit map[string]interface{}, subst map[string]map[string]interface{}) (jReport, bool) {
+	if status == "guard" {
+		if len(junbound(lit, subst)) > 0 {
+			return jReport{}, false
+		}
+		val, failed := jguard(m, h, lit, subst)
+		if failed {
+			return jReport{"UNDETERMINED", nil}, true
+		}
+		if val {
+			return jReport{"SATISFIED", nil}, true
+		}
+		return jReport{"NOT_SATISFIED", nil}, true
+	}
+	if jstr(lit["kind"]) != "literal" {
+		return jReport{"UNDETERMINED", nil}, true
+	}
+	args := jlist(lit, "args")
+	if len(junbound(args, subst)) > 0 {
+		return jReport{}, false
+	}
+	wild := false
+	for _, a := range args {
+		k := jstr(a.(map[string]interface{})["kind"])
+		if jComputed[k] {
+			return jReport{"UNDETERMINED", nil}, true
+		}
+		if k == "wildcard" {
+			wild = true
+		}
+	}
+	shown := jsubstArgs(lit, subst)
+	if wild {
+		// §98 (E-0165): свидетель существования, значение не связывается.
+		if jpolarity(lit) != "positive" || !(status == "established" || status == "supported" || status == "monotone") {
+			return jReport{"UNDETERMINED", shown}, true
+		}
+		want := []Val{}
+		wildAt := []bool{}
+		for _, a := range jlist(shown, "args") {
+			am := a.(map[string]interface{})
+			if jstr(am["kind"]) == "wildcard" {
+				want = append(want, nil)
+				wildAt = append(wildAt, true)
+			} else {
+				want = append(want, h.val(am))
+				wildAt = append(wildAt, false)
+			}
+		}
+		pred := jstr(lit["predicate"])
+		witness := false
+		for _, row := range m.tables()[pred] {
+			if len(row) != len(want) {
+				continue
+			}
+			all := true
+			for i := range row {
+				if !wildAt[i] && key([]Val{row[i]}) != key([]Val{want[i]}) {
+					all = false
+					break
+				}
+			}
+			if !all {
+				continue
+			}
+			st := m.truth(pred, row)
+			if (status == "established" && st == "TRUE_ONLY") || (status != "established" && (st == "TRUE_ONLY" || st == "BOTH")) {
+				witness = true
+				break
+			}
+		}
+		if witness {
+			return jReport{"SATISFIED", shown}, true
+		}
+		return jReport{"UNDETERMINED", shown}, true
+	}
+	pair := jtruth(m, h, shown)
+	switch status {
+	case "not_known":
+		if pair == "NEITHER" {
+			return jReport{"SATISFIED", shown}, true
+		}
+		return jReport{"NOT_SATISFIED", shown}, true
+	case "supported", "monotone":
+		if pair == "TRUE_ONLY" || pair == "BOTH" {
+			return jReport{"SATISFIED", shown}, true
+		}
+		return jReport{"UNDETERMINED", shown}, true
+	case "refuted", "unknown":
+		want := "FALSE_ONLY"
+		if status == "unknown" {
+			want = "NEITHER"
+		}
+		if pair == want {
+			return jReport{"SATISFIED", shown}, true
+		}
+		return jReport{"NOT_SATISFIED", shown}, true
+	}
+	tr, ok := jConjunct[pair]
+	if !ok {
+		tr = "UNDETERMINED"
+	}
+	return jReport{tr, shown}, true
+}
+
+// Порт `unify_head`: подстановка головы под ground-цель; переменная дважды — одинаково.
+func junify(head, target map[string]interface{}) (map[string]map[string]interface{}, bool) {
+	if jstr(head["kind"]) != "literal" || jstr(target["kind"]) != "literal" {
+		return nil, false
+	}
+	if jstr(head["predicate"]) != jstr(target["predicate"]) || jpolarity(head) != jpolarity(target) {
+		return nil, false
+	}
+	h, g := jlist(head, "args"), jlist(target, "args")
+	if len(h) != len(g) {
+		return nil, false
+	}
+	subst := map[string]map[string]interface{}{}
+	for i := range h {
+		hm, gm := h[i].(map[string]interface{}), g[i].(map[string]interface{})
+		if jstr(hm["kind"]) == "var" {
+			name := jstr(hm["var"])
+			if prev, ok := subst[name]; ok && jcanon(prev) != jcanon(gm) {
+				return nil, false
+			}
+			subst[name] = gm
+		} else if jcanon(hm) != jcanon(gm) {
+			return nil, false
+		}
+	}
+	return subst, true
+}
+
+// DECISION-0036 (б): перечисление судейского конъюнкта по активному домену —
+// аргументы всех атомов таблиц, порядок §208, кап ДО фильтра по NEITHER.
+func jenumerate(m jModel, h jHooks, lit map[string]interface{}, subst map[string]map[string]interface{}, unbound []string) []map[string]interface{} {
+	args := jlist(lit, "args")
+	for _, a := range args {
+		if jstr(a.(map[string]interface{})["kind"]) == "wildcard" {
+			return nil
+		}
+	}
+	domain := map[string]map[string]interface{}{}
+	for pred, rows := range m.tables() {
+		for _, row := range rows {
+			for i, v := range row {
+				t := h.cell(pred, i, v)
+				domain[jcanon(t)] = t
+			}
+		}
+	}
+	keys := make([]string, 0, len(domain))
+	for k := range domain {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	if len(keys) == 0 {
+		return nil
+	}
+	total := 1
+	for range unbound {
+		total *= len(keys)
+		if total > judgmentEnumCap {
+			total = judgmentEnumCap + 1
+			break
+		}
+	}
+	out := []map[string]interface{}{}
+	for idx := 0; idx < total && idx < judgmentEnumCap; idx++ {
+		// itertools.product: первая переменная меняется медленнее всех.
+		full := map[string]map[string]interface{}{}
+		for k, v := range subst {
+			full[k] = v
+		}
+		rest := idx
+		for j := len(unbound) - 1; j >= 0; j-- {
+			full[unbound[j]] = domain[keys[rest%len(keys)]]
+			rest /= len(keys)
+		}
+		ground := jsubstArgs(lit, full)
+		if jtruth(m, h, ground) == "NEITHER" {
+			out = append(out, ground)
+		}
+	}
+	return out
+}
+
+func jrowKey(h jHooks, lit map[string]interface{}) string {
+	args := jlist(lit, "args")
+	row := make([]Val, len(args))
+	for i, a := range args {
+		row[i] = h.val(a.(map[string]interface{}))
+	}
+	return key(row)
+}
+
+// E-0103: поражён ли был бы вывод поражаемого правила при любом ответе судьи.
+func jconclusionDefeated(m jModel, h jHooks, rule, target map[string]interface{}) bool {
+	if jstr(rule["strength"]) != "defeasible" {
+		return false
+	}
+	tkey, pos := jrowKey(h, target), jpolarity(target) != "negative"
+	for _, a := range m.applied() {
+		if !a.defeater || a.urn != jstr(target["predicate"]) || a.key != tkey || a.positive != pos {
+			continue
+		}
+		if !m.prioHas(jstr(rule["name"]), a.rule) {
+			return true
+		}
+	}
+	return false
+}
+
+// E-0100: способен ли живой дефитер снять СТОЯЩИЙ вывод.
+func jdefeaterCanRemove(m jModel, h jHooks, rule, target map[string]interface{}) bool {
+	args := jlist(target, "args")
+	row := make([]Val, len(args))
+	for i, a := range args {
+		row[i] = h.val(a.(map[string]interface{}))
+	}
+	pos := jpolarity(target) != "negative"
+	side := 2
+	if pos {
+		side = 1
+	}
+	if m.supportBits(jstr(target["predicate"]), row)&side != 0 {
+		return false
+	}
+	tkey := key(row)
+	apps := []appliedCand{}
+	for _, a := range m.applied() {
+		if !a.defeater && !a.defeated && a.urn == jstr(target["predicate"]) && a.key == tkey && a.positive == pos {
+			apps = append(apps, a)
+		}
+	}
+	if len(apps) == 0 {
+		return false
+	}
+	for _, a := range apps {
+		if m.prioHas(a.rule, jstr(rule["name"])) {
+			return false
+		}
+	}
+	return true
+}
+
+// Порт `whynot._collect_judgments`: общий обход §185 от цели без опоры
+// (rootDefeaters=false) и от стоящей цели через дефитеры её головы (true).
+func collectJudgments(m jModel, h jHooks, goal map[string]interface{}, rootDefeaters bool) []map[string]interface{} {
+	J := m.decls()
+	rules, _ := m.backchain()
+	index := map[string][]map[string]interface{}{}
+	for _, x := range rules {
+		r := x.(map[string]interface{})
+		pred := jstr(jfield(r, "head")["predicate"])
+		index[pred] = append(index[pred], r)
+	}
+	found := map[string]map[string]interface{}{}
+	order := []string{}
+	visited := map[string]bool{}
+	now := m.legalTime()
+	add := func(g map[string]interface{}) {
+		k := requestKey(g)
+		if _, ok := found[k]; !ok {
+			found[k] = g
+			order = append(order, k)
+		}
+	}
+	type rep struct {
+		st  string
+		lit map[string]interface{}
+		r   jReport
+		ok  bool
+	}
+	var walk func(target map[string]interface{}, defeatersOnly bool)
+	walk = func(target map[string]interface{}, defeatersOnly bool) {
+		vkey := jcanon(map[string]interface{}{"p": target["predicate"], "a": jlist(target, "args"), "n": jpolarity(target)})
+		if visited[vkey] {
+			return
+		}
+		visited[vkey] = true
+		for _, r := range index[jstr(target["predicate"])] {
+			if defeatersOnly && jstr(r["strength"]) != "defeater" {
+				continue
+			}
+			subst, ok := junify(jfield(r, "head"), target)
+			if !ok {
+				continue
+			}
+			if w := jfield(r, "window"); w != nil {
+				if s := jstr(w["start"]); s != "" && now < s {
+					continue
+				}
+				if e := jstr(w["end"]); e != "" && now >= e {
+					continue
+				}
+			}
+			reports := []rep{}
+			for _, c := range jlist(r, "body") {
+				pair := c.([]interface{})
+				st, lit := jstr(pair[0]), pair[1].(map[string]interface{})
+				rp, bound := jconjunct(m, h, st, lit, subst)
+				reports = append(reports, rep{st, lit, rp, bound})
+			}
+			dead := false
+			for _, x := range reports {
+				if !x.ok || (x.r.trigger != "NOT_SATISFIED" && x.r.trigger != "CONFLICTED") {
+					continue
+				}
+				// DECISION-0036 (а): refuted-тест над самим отношением суждения при паре NEITHER решает судья.
+				if x.st == "refuted" && x.r.ground != nil {
+					if _, isJ := J[jstr(x.r.ground["predicate"])]; isJ && jtruth(m, h, x.r.ground) == "NEITHER" {
+						continue
+					}
+				}
+				dead = true
+				break
+			}
+			if dead || jconclusionDefeated(m, h, r, target) {
+				continue
+			}
+			if defeatersOnly && !jdefeaterCanRemove(m, h, r, target) {
+				continue
+			}
+			for _, x := range reports {
+				if !x.ok {
+					if _, isJ := J[jstr(x.lit["predicate"])]; jTestable[x.st] && jstr(x.lit["kind"]) == "literal" && isJ {
+						for _, g := range jenumerate(m, h, x.lit, subst, junbound(jlist(x.lit, "args"), subst)) {
+							add(g)
+						}
+					}
+					continue
+				}
+				ground := x.r.ground
+				if ground == nil || jstr(ground["kind"]) != "literal" {
+					continue
+				}
+				hasWild := false
+				for _, a := range jlist(ground, "args") {
+					if jstr(a.(map[string]interface{})["kind"]) == "wildcard" {
+						hasWild = true
+					}
+				}
+				if hasWild {
+					continue
+				}
+				_, isJ := J[jstr(ground["predicate"])]
+				if x.r.trigger == "UNDETERMINED" {
+					if isJ {
+						add(ground)
+					} else {
+						walk(ground, false)
+					}
+				} else if x.st == "refuted" && x.r.trigger == "NOT_SATISFIED" && isJ && jtruth(m, h, ground) == "NEITHER" {
+					add(ground)
+				}
+			}
+		}
+	}
+	walk(goal, rootDefeaters)
+	out := make([]map[string]interface{}, len(order))
+	for i, k := range order {
+		out[i] = found[k]
+	}
+	return out
+}
+
+func jlitLiteral(h jHooks, n *jLit) map[string]interface{} {
+	args := make([]interface{}, len(n.row))
+	for i, v := range n.row {
+		args[i] = h.cell(n.pred, i, v)
+	}
+	pol := "negative"
+	if n.positive {
+		pol = "positive"
+	}
+	return map[string]interface{}{"kind": "literal", "polarity": pol, "predicate": n.pred, "args": args}
+}
+
+func jlitStatus(m jModel, n *jLit) string {
+	st := m.truth(n.pred, n.row)
+	if n.positive {
+		return st
+	}
+	return jMirror[st]
+}
+
+// E-0100, носитель `valid_when` §127: судьи действительности осуществлённого
+// полномочия, чей эффект есть цель; E-0120 — не при эффекте, запертом иммунитетом.
+func powerJudgments(m jModel, h jHooks, goal map[string]interface{}) []map[string]interface{} {
+	J := m.decls()
+	if jpolarity(goal) != "positive" {
+		return nil
+	}
+	args := jlist(goal, "args")
+	row := make([]Val, len(args))
+	for i, a := range args {
+		row[i] = h.val(a.(map[string]interface{}))
+	}
+	if m.blockedImmunity(jstr(goal["predicate"]), row) {
+		return nil
+	}
+	gkey := key(row)
+	out := []map[string]interface{}{}
+	for _, p := range m.positions() {
+		if p.modality != "power" || p.status != "ACTIVE" || p.effect == nil {
+			continue
+		}
+		if !p.effect.positive || p.effect.pred != jstr(goal["predicate"]) || key(p.effect.row) != gkey {
+			continue
+		}
+		if p.exercise == nil {
+			continue
+		}
+		if st := jlitStatus(m, p.exercise); st != "TRUE_ONLY" && st != "BOTH" {
+			continue
+		}
+		if p.validWhen == nil {
+			continue
+		}
+		if _, isJ := J[p.validWhen.pred]; !isJ {
+			continue
+		}
+		if jlitStatus(m, p.validWhen) == "NEITHER" {
+			out = append(out, jlitLiteral(h, p.validWhen))
+		}
+	}
+	return orderRequests(out)
+}
+
+// E-0100, носитель `condition` цели §123/§124: судьи статуса позиции обязанности.
+func positionJudgments(m jModel, h jHooks) []map[string]interface{} {
+	J := m.decls()
+	out := []map[string]interface{}{}
+	for _, p := range m.positions() {
+		if (p.status != "ACTIVE" && p.status != "UNDETERMINED") || p.cond == nil {
+			continue
+		}
+		if _, isJ := J[p.cond.pred]; !isJ {
+			continue
+		}
+		if jlitStatus(m, p.cond) == "NEITHER" {
+			out = append(out, jlitLiteral(h, p.cond))
+		}
+	}
+	return orderRequests(out)
+}
+
+// JudgmentRequest схемы evaluation по упорядоченным блокерам (без proof-узла).
+func buildRequests(m jModel, blockers []map[string]interface{}, tail string) []map[string]interface{} {
+	J := m.decls()
+	out := make([]map[string]interface{}, len(blockers))
+	for i, b := range blockers {
+		pred := jstr(b["predicate"])
+		d, ok := J[pred]
+		authority := pred
+		if ok {
+			authority = d.Authority
+		}
+		args := jlist(b, "args")
+		if args == nil {
+			args = []interface{}{}
+		}
+		r := map[string]interface{}{"id": "urn:judgment:" + tail + ":" + strconv.Itoa(i), "predicate": pred, "authority": authority,
+			"request": map[string]interface{}{"relation": pred, "polarity": jpolarity(b), "args": args}}
+		if ok && d.RequestSchema != nil {
+			r["requestSchema"] = d.RequestSchema
+		}
+		out[i] = r
+	}
+	return out
+}
+
+// Порт ветвей `queries.query_truth`: цель — отношение суждения без опоры;
+// цель без опоры — тела правил и `valid_when`; стоящая цель — дефитеры головы.
+func judgmentBlockers(m jModel, h jHooks, goal map[string]interface{}, status string, conflict bool) []map[string]interface{} {
+	J := m.decls()
+	if len(J) == 0 {
+		return nil
+	}
+	unresolved := status == "NEITHER" && !conflict
+	if _, isJ := J[jstr(goal["predicate"])]; isJ && unresolved {
+		return []map[string]interface{}{goal}
+	}
+	if unresolved {
+		return orderRequests(append(collectJudgments(m, h, goal, false), powerJudgments(m, h, goal)...))
+	}
+	if status == "TRUE_ONLY" && !conflict {
+		return orderRequests(collectJudgments(m, h, goal, true))
+	}
+	return nil
+}
+
+var jKinds = map[string]string{
+	"urn:law:std#Boolean": "boolean", "urn:law:std#Decimal": "decimal", "urn:law:std#Text": "text", "urn:law:std#Date": "date",
+	"urn:law:std#Instant": "instant", "urn:law:std#Integer": "integer", "urn:law:std#Natural": "integer",
+	"urn:law:std#Money": "money", "urn:law:std#Quantity": "quantity", "urn:law:std#Rational": "rational",
+}
+
+// §47.3.1 (E-0089): ответ судьи с объектом `judgment` — орган и форма payload.
+// Возвращает код issue либо "" (ответ принят).
+func judgmentAnswer(m jModel, pred string, judgment map[string]interface{}) string {
+	if judgment == nil {
+		return ""
+	}
+	d, ok := m.decls()[pred]
+	authority := pred
+	if ok {
+		authority = d.Authority
+	}
+	if jstr(judgment["authority"]) != authority {
+		return "JUDGMENT_AUTHORITY_MISMATCH"
+	}
+	payload, has := judgment["payload"].(map[string]interface{})
+	if judgment["payload"] != nil && has {
+		if !ok || d.RequestSchema == nil {
+			return "JUDGMENT_PAYLOAD_MISMATCH"
+		}
+		schema, _ := d.RequestSchema.(map[string]interface{})
+		want, known := jKinds[jstr(schema["name"])]
+		if known {
+			got := "enum"
+			switch jstr(payload["kind"]) {
+			case "value":
+				got = jKinds[jstr(jfield(payload, "type")["name"])]
+			case "entity_ref":
+				got = "entity_ref"
+			}
+			if got != want {
+				return "JUDGMENT_PAYLOAD_MISMATCH"
+			}
+		}
+	}
+	return ""
+}
+
+// Ключ кандидата страты для учёта выживших (DECISION-0274).
+func candKey(rule, urn, k string, positive bool) string {
+	if positive {
+		return rule + "|" + urn + "|" + k + "|+"
+	}
+	return rule + "|" + urn + "|" + k + "|-"
+}
+
+func admitNumericInputs(kase, query map[string]interface{}, judgments bool) {
+	stack := []interface{}{query}
+	assertions, _ := kase["assertions"].([]interface{})
+	for _, v := range assertions {
+		a, _ := v.(map[string]interface{})
+		stack = append(stack, a["literal"])
+	}
+	for len(stack) > 0 {
+		n := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		switch x := n.(type) {
+		case []interface{}:
+			stack = append(stack, x...)
+		case map[string]interface{}:
+			t, _ := x["type"].(map[string]interface{})
+			if x["kind"] == "value" && t["name"] == "urn:law:std#Number" {
+				refuse("NUMBER_UNAVAILABLE: exact Number and slot narrowing (E-0316/E-0319/E-0334) are outside this slice")
+			}
+			if judgments && (x["kind"] == "aggregate" || x["kind"] == "comprehension") {
+				refuse("AGGREGATE_JUDGMENT_UNAVAILABLE: open aggregate members require E-0357")
+			}
+			for _, v := range x {
+				switch v.(type) {
+				case []interface{}, map[string]interface{}:
+					stack = append(stack, v)
+				}
+			}
+		}
+	}
+}