arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/go/evaluate.go

@@ -0,0 +1,1826 @@
+package main
+
+// Единый вычислительный вход Go-цели (DECISION-0423 §2.2).
+//
+// Дело и вопрос приходят канонической JSON-записью (§168, §172) — той же, что у
+// векторов и оракула, — и `evaluate` возвращает ответ исполняемого профиля той же
+// JSON-строкой, что раньше печатал раннер. Раннер и API вызывают только его,
+// поэтому разбор сырых литералов §208, сверка аргументов §189, разворот контекста,
+// насыщение и лестница статусов §175 у них одни. Состояние — на вызов (§2.3):
+// модель строит `newModel()`, контекст вычисления живёт в ней, сопутствующие
+// множества — в `evaluation`; глобального состояния и мьютекса нет. Ответ — БЕЗ
+// доказательства и хэшей: профиль core-executable.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"sort"
+	"strings"
+)
+
+// Model — хуки экземпляра модели (DECISION-0423 §2.3): `newModel()` порождённого
+// model.go строит таблицы и правила замыканиями над ними и заполняет эти поля.
+type Model struct {
+	NODE_IDS              map[string]bool
+	ctx                   *evalContext
+	TABLES                map[string][][]Val
+	PARAMS                map[string][]string
+	CONSTS                map[string]constDecl
+	BASES                 map[string]string
+	FUNCTIONS             map[string]funcDecl
+	A3_TYPES              map[string]string
+	KEY_READERS           map[string][]string
+	CARRIER_EDGES         map[string][]string
+	saturate              func()
+	register              func(urn string, row []Val)
+	registerNegative      func(urn string, row []Val)
+	packageFacts          func()
+	keyConflicts          func() int
+	keyConflictPredicates func() map[string]bool
+	truthOf               func(urn string, row []Val) string
+	establishedRows       func(urn string) [][]Val
+	ruleIssues            func() []string
+	normIssues            func() []string
+	normPositions         func() ([]normPosition, bool)
+	blockedEffect         func(pred string, row []Val) bool
+	calendarEnv           func() (string, map[string]interface{}, []Snapshot, bool)
+	backchainEnv          func() ([]interface{}, map[string]interface{}, map[string]bool, bool)
+	judgmentModel         func() jModel
+	setStatusTime         func(t string)
+}
+
+// evaluation — одно вычисление: экземпляр модели, дело и вопрос, сопутствующие множества.
+type evaluation struct {
+	m                   *Model
+	caseRaw, queryRaw   []byte
+	issues              []string
+	typeErrorPredicates map[string]bool
+	// Запись строки, поданная делом как сущность и как Text, — в рантайме одно
+	// значение, у оракула — разные атомы. Для печати результата вид берётся по
+	// тому, как запись подана; одна запись в обеих ролях — названный отказ.
+	entities, texts map[string]bool
+	lastTermCodes   map[string]bool
+	hooks           jHooks
+	api             bool // разрешён внутренний вид `rows` (DECISION-0423 §2.1)
+}
+
+// RefusedError — названный отказ среза (DECISION-0423 §2.5): значение `error`,
+// распознаваемое `errors.As`; паники на границе входа нет.
+type RefusedError struct{ Message string }
+
+func (r *RefusedError) Error() string { return r.Message }
+
+// evaluate — ответ на вопрос по делу JSON-строкой; названный отказ — *RefusedError.
+func evaluate(caseJSON, queryJSON []byte) (string, error) {
+	return evaluateWith(caseJSON, queryJSON, false)
+}
+
+// evaluateRows — то же с внутренним видом API `rows`, которого протокол раннера не знает.
+func evaluateRows(caseJSON, queryJSON []byte) (string, error) {
+	return evaluateWith(caseJSON, queryJSON, true)
+}
+
+func evaluateWith(caseJSON, queryJSON []byte, api bool) (answer string, err error) {
+	var requested struct {
+		Kind string `json:"kind"`
+	}
+	if json.Unmarshal(queryJSON, &requested) == nil && requested.Kind == "positions" {
+		return "", &RefusedError{"POSITIONS_UNAVAILABLE: positions requires current norm ranks (W6)"}
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			if msg, ok := r.(Refused); ok {
+				answer, err = "", &RefusedError{string(msg)}
+				return
+			}
+			if te, ok := r.(termError); ok {
+				// Ошибка значения вне вопроса `term` и вне правил модели (гард
+				// comprehension вопроса) — названный отказ, а не крах.
+				answer, err = "", &RefusedError{"ошибка значения вне среза раннера: " + te.code}
+				return
+			}
+			panic(r)
+		}
+	}()
+	validateTemporalCase(caseJSON)
+	ev := &evaluation{m: newModel(), caseRaw: caseJSON, queryRaw: queryJSON, issues: []string{},
+		typeErrorPredicates: map[string]bool{}, entities: map[string]bool{}, texts: map[string]bool{},
+		lastTermCodes: map[string]bool{}, api: api}
+	var admissionCase, admissionQuery map[string]interface{}
+	_ = json.Unmarshal(caseJSON, &admissionCase)
+	_ = json.Unmarshal(queryJSON, &admissionQuery)
+	assertions, _ := admissionCase["assertions"].([]interface{})
+	for _, value := range assertions {
+		a, _ := value.(map[string]interface{})
+		if ev.m.NODE_IDS[str(a["id"])] {
+			refuse("LDC-E1382: case assertion id collides with a program node")
+		}
+	}
+	admitNumericInputs(admissionCase, admissionQuery, len(ev.m.judgmentModel().decls()) > 0)
+	// Обход запроса судье §47.3 (DECISION-0274): переводы термов раннера для рантайма;
+	// множества сущностей и текстов дела обходом не двигаются.
+	ev.hooks = jHooks{
+		val: func(a map[string]interface{}) Val { return ev.typedArg(a).v },
+		cell: func(pred string, col int, v Val) map[string]interface{} {
+			var out map[string]interface{}
+			d := json.NewDecoder(strings.NewReader(literalOf(ev.slotTyped(pred, col, v))))
+			d.UseNumber()
+			if err := d.Decode(&out); err != nil {
+				panic(err)
+			}
+			return out
+		},
+	}
+	return ev.run(), nil
+}
+
+// Обобщённый разбор JSON: числа — json.Number, чтобы длинное целое не теряло знаков.
+func decodeGeneric(b []byte) map[string]interface{} {
+	d := json.NewDecoder(bytes.NewReader(b))
+	d.UseNumber()
+	var v map[string]interface{}
+	if err := d.Decode(&v); err != nil {
+		panic(err)
+	}
+	return v
+}
+
+func mustUnmarshal(b []byte, v interface{}) {
+	if err := json.Unmarshal(b, v); err != nil {
+		panic(err)
+	}
+}
+
+type argJSON struct {
+	Kind     string          `json:"kind"`
+	ID       string          `json:"id"`
+	Value    json.RawMessage `json:"value"`
+	Currency string          `json:"currency"`
+	Unit     string          `json:"unit"`
+	Type     struct {
+		Name string `json:"name"`
+	} `json:"type"`
+}
+
+type litJSON struct {
+	Predicate string    `json:"predicate"`
+	Polarity  string    `json:"polarity"`
+	Args      []argJSON `json:"args"`
+}
+
+func literal(raw json.RawMessage) string {
+	if len(raw) > 0 && raw[0] == '"' {
+		var s string
+		if err := json.Unmarshal(raw, &s); err != nil {
+			panic(err)
+		}
+		return s
+	}
+	return string(raw)
+}
+
+// §208/§48 (errata E-0197, E-0202, E-0203): вид JSON-носителя сырого поля
+// литерала и его текст — "s" (JSON-строка), "i" (целое JSON-число канона),
+// "x" (любая другая форма, включая отсутствие поля: схема LiteralTerm не
+// требует `value`). Отсюда и только отсюда читают `lit*` рантайма.
+func rawOfMessage(raw json.RawMessage) (string, string) {
+	s := strings.TrimSpace(string(raw))
+	if s == "" || s == "null" || s == "true" || s == "false" {
+		return "x", ""
+	}
+	if s[0] == '"' {
+		var v string
+		if err := json.Unmarshal(raw, &v); err != nil {
+			return "x", ""
+		}
+		return "s", v
+	}
+	if s[0] == '-' || (s[0] >= '0' && s[0] <= '9') {
+		return canonNumberText(s)
+	}
+	return "x", ""
+}
+
+// То же по значению обобщённого разбора: числа приходят `json.Number`
+// (`UseNumber`), то есть текстом исходного литерала, а не float64.
+func rawOfValue(v interface{}) (string, string) {
+	switch x := v.(type) {
+	case string:
+		return "s", x
+	case json.Number:
+		return canonNumberText(x.String())
+	}
+	return "x", ""
+}
+
+func (ev *evaluation) toVal(a argJSON) Val {
+	if a.Kind == "entity_ref" {
+		ev.entities[a.ID] = true
+		return a.ID
+	}
+	if a.Kind == "const_ref" {
+		// §54: разыменование предшествует исполнению; ниже ссылок нет.
+		c, ok := ev.m.CONSTS[a.ID]
+		if !ok {
+			// Член перечисления §38 либо имя без объявления: оракул оставляет
+			// такой const_ref в ключе атома как есть — значение есть идентичность.
+			return sym(a.ID)
+		}
+		return c.Value
+	}
+	if a.Kind != "value" {
+		refuse("аргумент вне среза раннера: " + a.Kind)
+	}
+	// §208/§48 (errata E-0197, E-0202, E-0203): сырое поле литерала читается по
+	// грамматике §208, а не байтами `json.RawMessage`: до errata литерал без
+	// `value` выходил у go значением "" (а у ts — "undefined"), то есть ответом,
+	// а не диагностикой.
+	k, text := rawOfMessage(a.Value)
+	switch a.Type.Name {
+	case "urn:law:std#Money":
+		ck, ctext := "s", a.Currency
+		return litMoney(k, text, ck, ctext)
+	case "urn:law:std#Decimal":
+		return litDec(k, text)
+	case "urn:law:std#Integer":
+		return litInt(k, text)
+	case "urn:law:std#Text":
+		s := litText(k, text)
+		ev.texts[s] = true
+		return s
+	case "urn:law:std#Date":
+		return date(litText(k, text))
+	case "urn:law:std#Instant":
+		return instant(litText(k, text))
+	case "urn:law:std#Rational":
+		// §168.1 (DECISION-0252 п. 8): только каноническая запись, иная — отказ.
+		return rat(litText(k, text))
+	case "urn:law:std#Quantity":
+		// §49 v1 (DECISION-0256 п. 7): значение и тег единицы как записаны.
+		if a.Unit != "" {
+			return litQty(k, text, "s", a.Unit)
+		}
+	case "urn:law:std#Boolean":
+		// DECISION-0266: только JSON-булево; иная запись у оракула — TYPE_ERROR при чтении значения.
+		var b bool
+		if err := json.Unmarshal(a.Value, &b); err != nil {
+			refuse("значение Boolean не true/false вне среза раннера (§48)")
+		}
+		return b
+	case "urn:law:std#Natural":
+		// DECISION-0266: неотрицательное целое; иное у оракула — TYPE_ERROR при чтении значения.
+		if k != "i" || strings.HasPrefix(text, "-") {
+			refuse("значение Natural не неотрицательное целое вне среза раннера (§48)")
+		}
+		return litInt(k, text)
+	}
+	refuse("аргумент вне среза раннера: " + a.Type.Name)
+	return nil
+}
+
+// Тип аргумента, если известен: у value — из узла, у const_ref — из
+// объявления константы; entity_ref типа не несёт (как у оракула).
+func (ev *evaluation) argType(a argJSON) (string, bool) {
+	if a.Kind == "value" {
+		return a.Type.Name, true
+	}
+	if a.Kind == "const_ref" {
+		// Оракул разыменовывает константы §54 до сверки: сущность и член
+		// перечисления типа не несут, тип — только у константы std-типа.
+		c, ok := ev.m.CONSTS[a.ID]
+		return c.Type, ok && strings.HasPrefix(c.Type, "urn:law:std#")
+	}
+	return "", false
+}
+
+// Совпадение типа с наследованием сущностей вверх от фактического.
+func (ev *evaluation) conforms(actual, expected string) bool {
+	seen := map[string]bool{}
+	cur := actual
+	for cur != "" && !seen[cur] {
+		if cur == expected {
+			return true
+		}
+		seen[cur] = true
+		cur = ev.m.BASES[cur]
+	}
+	return false
+}
+
+// Арность и типы аргументов утверждения против сигнатуры §189 (E-0046) —
+// зеркало check_argument_types оракула: несогласованное утверждение не
+// принимается, причина названа кодом TYPE_ERROR; entity_ref типа не несёт;
+// предикат без сигнатуры принимается (его никто не читает). Проверка идёт
+// ДО преобразования значений.
+func (ev *evaluation) wellTyped(lit litJSON) bool {
+	params, ok := ev.m.PARAMS[lit.Predicate]
+	if !ok {
+		return true
+	}
+	if len(lit.Args) != len(params) {
+		ev.issues = append(ev.issues, "TYPE_ERROR")
+		ev.typeErrorPredicates[lit.Predicate] = true
+		return false
+	}
+	for i, a := range lit.Args {
+		if actual, known := ev.argType(a); known && !ev.conforms(actual, params[i]) {
+			ev.issues = append(ev.issues, "TYPE_ERROR")
+			ev.typeErrorPredicates[lit.Predicate] = true
+			return false
+		}
+	}
+	return true
+}
+
+func (ev *evaluation) queryTyped(lit litJSON) bool {
+	params, ok := ev.m.PARAMS[lit.Predicate]
+	if !ok || len(lit.Args) != len(params) {
+		return false
+	}
+	for i, a := range lit.Args {
+		if actual, known := ev.argType(a); known && !ev.conforms(actual, params[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// --- вопросы term §57–§59 и collect §52.1 -------------------------------------
+// Срез раннера: comprehension по установленным атомам таблиц с гардами,
+// элемент — ячейка или литерал; агрегаты count/sum/min/max; арифметика §58
+// и функции рантайма над результатом. Вид результата выводится статически
+// по тем же таблицам §58, что у плана: у оракула вид — часть значения
+// (Integer 5 и Decimal 5 — разные байты), у рантайма — нет.
+const (
+	tINT     = "urn:law:std#Integer"
+	tDEC     = "urn:law:std#Decimal"
+	tMON     = "urn:law:std#Money"
+	tTEXT    = "urn:law:std#Text"
+	tDATE    = "urn:law:std#Date"
+	tINSTANT = "urn:law:std#Instant"
+	tRAT     = "urn:law:std#Rational"
+	tQTY     = "urn:law:std#Quantity"
+	tBOOL    = "urn:law:std#Boolean"
+	tNAT     = "urn:law:std#Natural"
+)
+
+// DECISION-0266: Natural считает как Integer (`values._TYPE_KINDS`), тип-строка своя.
+func normKind(t string) string {
+	if t == tNAT {
+		return tINT
+	}
+	return t
+}
+
+// §59 (errata E-0195): вид элемента ПУСТОЙ коллекции несёт ОБЪЯВЛЕННЫЙ тип
+// проекции comprehension §52.1 (`variable.type.name`) — единственный носитель
+// вида, не зависящий от числа решений generator-а (порт
+// `values.aggregate_element_type`). Таблица — порт `values._TYPE_KINDS` плюс
+// `_OPAQUE_KINDS`: Natural и Integer у оракула один вид `integer`. Имя вне
+// таблицы (сущность, перечисление, чужой символ) вида не предъявляет, и сверка
+// МОЛЧИТ: Unknown есть «утверждать нечего», а не «совместимо со всем».
+var emptyElementKinds = map[string]string{
+	tINT: tINT, tNAT: tINT, tDEC: tDEC, tMON: tMON, tTEXT: tTEXT, tDATE: tDATE,
+	tBOOL: tBOOL, tRAT: tRAT, tQTY: tQTY,
+	"urn:law:std#Instant":   "urn:law:std#Instant",
+	"urn:law:std#Magnitude": "urn:law:std#Magnitude",
+	"urn:law:std#Bounds":    "urn:law:std#Bounds",
+}
+
+// Имя функции рантайма по имени std-функции вопроса (DECISION-0267).
+var rtName = map[string]string{"month_start_of": "month_start", "month_end_of": "month_end"}
+
+// Сравнения §57 в вычислимом терме вопроса: исход — Boolean.
+func isCmpOp(op string) bool {
+	switch op {
+	case "lt", "le", "gt", "ge", "eq", "ne":
+		return true
+	}
+	return false
+}
+
+// DECISION-0252 п. 3: вид операнда для `arith` рантайма. У вопроса вид каждого
+// значения известен точно — из литерала, слота или исхода операции.
+var kindCode = map[string]string{tINT: "i", tDEC: "d", tMON: "m", tRAT: "r", tQTY: "q", tNAT: "i"}
+
+type typed struct {
+	v Val
+	t string // URN типа std либо "entity" | "enum"
+}
+
+type env map[string]typed
+
+func isNumT(t string) bool {
+	return t == tINT || t == tDEC || t == tMON || t == tRAT || t == tQTY || t == tNAT
+}
+
+func arithKind(op, l, r string) string {
+	l, r = normKind(l), normKind(r)
+	if !isNumT(l) || !isNumT(r) {
+		refuse("арифметика вне среза (§58): не числовой операнд " + op)
+	}
+	switch op {
+	case "add", "sub":
+		if l != r {
+			refuse("арифметика вне среза (§58): виды операндов не совпадают у " + op)
+		}
+		return l
+	case "mul":
+		if l == tMON && r == tMON {
+			refuse("арифметика вне среза (§58): произведение двух размерных величин не определено")
+		}
+		if l == tINT {
+			return r
+		}
+		if r == tINT {
+			return l
+		}
+		if l == tMON || r == tMON {
+			return tMON
+		}
+		return tDEC
+	case "div":
+		if (l == tDEC && r == tDEC) || (l == tMON && r == tMON) {
+			return tDEC
+		}
+		if l == tMON && r == tDEC {
+			return tMON
+		}
+		if l == tINT && r == tINT {
+			refuse("арифметика вне среза (§58): частное Integer/Integer — Rational")
+		}
+		refuse("арифметика вне среза (§58): пара вне таблицы делимых")
+	case "mod":
+		if l != tINT || r != tINT {
+			refuse("арифметика вне среза (§58): остаток только Integer mod Integer")
+		}
+		return tINT
+	}
+	refuse("операция вне среза раннера: " + op)
+	return ""
+}
+
+func callKind(fn string, ks []string) string {
+	switch fn {
+	case "min", "max":
+		if len(ks) != 2 || !isNumT(ks[0]) || ks[0] != ks[1] {
+			refuse("арифметика вне среза (§58): виды операндов не совпадают у " + fn)
+		}
+		return ks[0]
+	case "abs":
+		if len(ks) != 1 || !isNumT(ks[0]) {
+			refuse("арифметика вне среза (§58): abs над нечисловым видом")
+		}
+		return ks[0]
+	case "pow":
+		if len(ks) != 2 || ks[0] != tINT || ks[1] != tINT {
+			refuse("арифметика вне среза (§58): pow только Integer pow Integer")
+		}
+		return tINT
+	case "round":
+		if len(ks) != 3 {
+			refuse("round вне среза раннера: ожидаются значение, разряды и режим (§50)")
+		}
+		if ks[0] == tRAT {
+			refuse("round над Rational вне среза генератора (§50: round не берёт Rational)")
+		}
+		if !isNumT(ks[0]) {
+			refuse("round вне среза генератора: вид операнда не числовой (§50)")
+		}
+		policyKinds("round", ks[1:])
+		return ks[0]
+	case "div_round":
+		// §50/§58 (E-0036, E-0170; DECISION-0259 п. 3): четыре пары видов.
+		if len(ks) != 4 {
+			refuse("div_round вне среза генератора: ожидаются делимое, делитель, точность и режим (§50)")
+		}
+		if ks[0] == tRAT || ks[1] == tRAT {
+			refuse("div_round над Rational вне среза генератора (§50/§58, E-0036)")
+		}
+		l, r := ks[0], ks[1]
+		if !((l == tMON && r == tDEC) || (l == tQTY && r == tDEC) || (l == tDEC && r == tDEC) || (l == tMON && r == tMON)) {
+			refuse("div_round вне среза генератора: пара видов вне E-0036/E-0170 (§50/§58)")
+		}
+		policyKinds("div_round", ks[2:])
+		if r == tDEC && (l == tMON || l == tQTY) {
+			return l
+		}
+		return tDEC
+	case "month_start_of", "month_end_of":
+		// §84.2 (E-0084, DECISION-0267): арность и вид — TYPE_ERROR оракула (`month_bound_value`).
+		if len(ks) != 1 || ks[0] != tDATE {
+			panic(termError{"TYPE_ERROR"})
+		}
+		return tDATE
+	case "hours_between", "minutes_between":
+		// §84.1 (E-0028/E-0058; W2 часть 2): оба аргумента — Instant, иначе TYPE_ERROR оракула.
+		if len(ks) != 2 || ks[0] != tINSTANT || ks[1] != tINSTANT {
+			panic(termError{"TYPE_ERROR"})
+		}
+		return tINT
+	case "add_duration":
+		refuse("add_duration в вопросе вне среза раннера (§84.1)")
+	}
+	refuse("функция вне среза раннера: " + fn)
+	return ""
+}
+
+// §50: точность — Integer либо Decimal, режим — Text (DECISION-0259 п. 3).
+func policyKinds(fn string, ks []string) {
+	if ks[0] != tINT && ks[0] != tDEC {
+		refuse(fn + " вне среза генератора: точность не Integer и не Decimal (§50)")
+	}
+	if ks[1] != tTEXT {
+		refuse(fn + " вне среза генератора: режим не Text (§50)")
+	}
+}
+
+func str(v interface{}) string {
+	switch x := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return x
+	case json.Number:
+		return x.String()
+	}
+	return fmt.Sprint(v)
+}
+
+func field(m map[string]interface{}, k string) map[string]interface{} {
+	if x, ok := m[k].(map[string]interface{}); ok {
+		return x
+	}
+	return map[string]interface{}{}
+}
+
+func list(m map[string]interface{}, k string) []interface{} {
+	if x, ok := m[k].([]interface{}); ok {
+		return x
+	}
+	return nil
+}
+
+// Литерал-терм §53 как typed-значение; тип сущности у entity_ref — "entity".
+func (ev *evaluation) typedArg(a map[string]interface{}) typed {
+	switch str(a["kind"]) {
+	case "entity_ref":
+		return typed{str(a["id"]), "entity"}
+	case "const_ref":
+		// DECISION-0273: параметр A3 в вопросе term — за срезом раннера (значение на legalTime дела).
+		if _, isA3 := ev.m.A3_TYPES[str(a["id"])]; isA3 {
+			refuse("параметр A3 в вопросе вне среза раннера: " + str(a["id"]))
+		}
+		c, ok := ev.m.CONSTS[str(a["id"])]
+		if !ok {
+			return typed{sym(str(a["id"])), "enum"}
+		}
+		return typed{c.Value, c.Type}
+	case "value":
+		t := str(field(a, "type")["name"])
+		// §208/§48 (errata E-0197, E-0202, E-0203): та же воронка, что у факта.
+		k, text := rawOfValue(a["value"])
+		switch t {
+		case tMON:
+			ck, ctext := rawOfValue(a["currency"])
+			return typed{litMoney(k, text, ck, ctext), t}
+		case tDEC:
+			return typed{litDec(k, text), t}
+		case tINT:
+			return typed{litInt(k, text), t}
+		case tTEXT:
+			return typed{litText(k, text), t}
+		case tDATE:
+			return typed{date(litText(k, text)), t}
+		case tINSTANT:
+			return typed{instant(litText(k, text)), t}
+		case tRAT:
+			return typed{rat(litText(k, text)), t}
+		case tQTY:
+			// §49 v1 (DECISION-0256 п. 7): без тега единицы — отказ, как у факта.
+			if uk, utext := rawOfValue(a["unit"]); utext != "" {
+				return typed{litQty(k, text, uk, utext), t}
+			}
+		case tBOOL:
+			b, ok := a["value"].(bool)
+			if !ok {
+				refuse("значение Boolean не true/false вне среза раннера (§48)")
+			}
+			return typed{b, t}
+		case tNAT:
+			if k != "i" || strings.HasPrefix(text, "-") {
+				refuse("значение Natural не неотрицательное целое вне среза раннера (§48)")
+			}
+			return typed{litInt(k, text), t}
+		}
+		refuse("аргумент вне среза раннера: " + t)
+	}
+	refuse("узел терма вне среза раннера: " + str(a["kind"]))
+	return typed{}
+}
+
+func (ev *evaluation) slotTyped(pred string, col int, v Val) typed {
+	t := ev.m.PARAMS[pred][col]
+	if s, ok := v.(string); ok {
+		ent, txt := ev.entities[s], ev.texts[s]
+		if ent && txt {
+			refuse("одна запись подана делом и сущностью, и Text: вид результата не определён в срезе")
+		}
+		if ent {
+			return typed{v, "entity"}
+		}
+		if txt {
+			return typed{v, tTEXT}
+		}
+		if t == tTEXT {
+			return typed{v, tTEXT}
+		}
+		return typed{v, "entity"}
+	}
+	if _, ok := v.(bool); ok {
+		return typed{v, tBOOL}
+	}
+	switch t {
+	case tMON, tDEC, tINT, tDATE, tRAT, tQTY, tNAT, tINSTANT:
+		return typed{v, t}
+	}
+	if _, ok := v.(Sym); ok {
+		return typed{v, "enum"}
+	}
+	return typed{v, "entity"}
+}
+
+func flatten(body map[string]interface{}, atoms *[]map[string]interface{}, guards *[]map[string]interface{}) {
+	switch str(body["kind"]) {
+	case "status":
+		if str(body["status"]) != "established" {
+			refuse("статусный тест вне L0-среза: " + str(body["status"]))
+		}
+		*atoms = append(*atoms, field(body, "formula"))
+	case "literal":
+		*atoms = append(*atoms, body)
+	case "comparison":
+		*guards = append(*guards, body)
+	case "and", "conjunction":
+		subs := list(body, "items")
+		if subs == nil {
+			subs = list(body, "args")
+		}
+		if subs == nil {
+			subs = list(body, "operands")
+		}
+		for _, s := range subs {
+			if m, ok := s.(map[string]interface{}); ok {
+				flatten(m, atoms, guards)
+			}
+		}
+	default:
+		refuse("форма тела вне среза генератора: " + str(body["kind"]))
+	}
+}
+
+// Data-условие §56 (`values.is_data_condition`): boolean, comparison, and, or.
+func (ev *evaluation) dataCond(f map[string]interface{}, e env) bool {
+	switch str(f["kind"]) {
+	case "boolean":
+		b, _ := f["value"].(bool)
+		return b
+	case "comparison":
+		v := ev.evalTerm(map[string]interface{}{"kind": "binary", "op": f["op"], "left": f["left"], "right": f["right"]}, e)
+		return v.v.(bool)
+	case "and":
+		for _, x := range list(f, "items") {
+			if !ev.dataCond(x.(map[string]interface{}), e) {
+				return false
+			}
+		}
+		return true
+	case "or":
+		for _, x := range list(f, "items") {
+			if ev.dataCond(x.(map[string]interface{}), e) {
+				return true
+			}
+		}
+		return false
+	}
+	refuse("условие терма §56 вне data-условия вне среза раннера: " + str(f["kind"]))
+	return false
+}
+
+func (ev *evaluation) evalTerm(node map[string]interface{}, e env) typed {
+	switch str(node["kind"]) {
+	case "var":
+		b, ok := e[str(node["var"])]
+		if !ok {
+			refuse("несвязанная переменная терма: " + str(node["var"]))
+		}
+		return b
+	case "value", "entity_ref", "const_ref":
+		if str(node["kind"]) == "value" && str(field(node, "type")["name"]) == tRAT {
+			// ERR-E0005: операнд вычисления разбирается как у оракула — сократимая
+			// запись нормализуется; каноничность §168.1 — у записей, не у операнда.
+			rk, rtext := rawOfValue(node["value"])
+			return typed{ratTerm(litText(rk, rtext)), tRAT}
+		}
+		return ev.typedArg(node)
+	case "binary":
+		l := ev.evalTerm(field(node, "left"), e)
+		r := ev.evalTerm(field(node, "right"), e)
+		op := str(node["op"])
+		if isCmpOp(op) {
+			// §57 (`values.binary`, `_check_same_kind`): валюта, единица, затем вид.
+			if l.t == tMON && r.t == tMON && l.v.(Money).Cur != r.v.(Money).Cur {
+				panic(termError{"CURRENCY_MISMATCH"})
+			}
+			if l.t == tQTY && r.t == tQTY && l.v.(Qty).Unit != r.v.(Qty).Unit {
+				panic(termError{"DIMENSION_MISMATCH"})
+			}
+			if (l.t == tDATE && r.t == tINSTANT) || (l.t == tINSTANT && r.t == tDATE) {
+				panic(termError{"DATE_INSTANT_MISMATCH"})
+			}
+			if normKind(l.t) != normKind(r.t) {
+				panic(termError{"TYPE_ERROR"})
+			}
+			if l.t == tBOOL {
+				// §57 (DECISION-0266): Boolean сравнимо только на равенство; порядок — TYPE_ERROR оракула.
+				if op != "eq" && op != "ne" {
+					panic(termError{"TYPE_ERROR"})
+				}
+				return typed{cmp(l.v, op, r.v), tBOOL}
+			}
+			if !isNumT(l.t) && l.t != tDATE && l.t != tINSTANT {
+				refuse("операция вне среза раннера: " + op)
+			}
+			return typed{cmp(l.v, op, r.v), tBOOL}
+		}
+		if !isNumT(l.t) || !isNumT(r.t) {
+			refuse("арифметика вне среза (§58): не числовой операнд " + op)
+		}
+		switch op {
+		case "add", "sub", "mul", "div", "mod":
+		default:
+			refuse("операция вне среза раннера: " + op)
+		}
+		// §58 `values.binary` (DECISION-0252 п. 8): вид исхода — по значению;
+		// ошибка значения — termError, ответ вопроса `term` — RUNTIME_ERROR.
+		v := arith(op, l.v, r.v, kindCode[l.t], kindCode[r.t])
+		switch v.(type) {
+		case Rational:
+			return typed{v, tRAT}
+		case Money:
+			return typed{v, tMON}
+		case Qty:
+			return typed{v, tQTY}
+		}
+		if normKind(l.t) == tINT && normKind(r.t) == tINT {
+			return typed{v, tINT}
+		}
+		return typed{v, tDEC}
+	case "call":
+		fn := str(node["function"])
+		if uf, isUser := ev.m.FUNCTIONS[fn]; isUser {
+			// DECISION-0273: функция §46 модуля; арность и типы аргументов — TYPE_ERROR
+			// оракула (`_require_type`), вид результата — объявленный.
+			var vals []Val
+			raw := list(node, "args")
+			if len(raw) != len(uf.Params) {
+				panic(termError{"TYPE_ERROR"})
+			}
+			for i, a := range raw {
+				t := ev.evalTerm(a.(map[string]interface{}), e)
+				want := uf.Params[i]
+				ok := t.t == "enum" || t.t == want
+				if strings.HasPrefix(want, "urn:law:std#") {
+					ok = normKind(t.t) == normKind(want)
+				}
+				if !ok {
+					panic(termError{"TYPE_ERROR"})
+				}
+				vals = append(vals, t.v)
+			}
+			rt := uf.Returns
+			if !strings.HasPrefix(rt, "urn:law:std#") {
+				rt = "enum"
+			}
+			return typed{uf.Fn(vals), rt}
+		}
+		if i := strings.LastIndex(fn, "#"); i >= 0 {
+			fn = fn[i+1:]
+		}
+		var args []typed
+		for _, a := range list(node, "args") {
+			args = append(args, ev.evalTerm(a.(map[string]interface{}), e))
+		}
+		ks := make([]string, len(args))
+		for i, a := range args {
+			ks[i] = a.t
+		}
+		t := callKind(fn, ks)
+		switch fn {
+		case "round":
+			// DECISION-0259: политика §50 проверяется рантаймом; виды вопроса точные.
+			return typed{roundMode(args[0].v, args[1].v, args[2].v, kindCode[args[0].t], kindCode[args[1].t]), t}
+		case "div_round":
+			return typed{divRound(args[0].v, args[1].v, args[2].v, args[3].v,
+				kindCode[args[0].t], kindCode[args[1].t], kindCode[args[2].t]), t}
+		case "min":
+			return typed{min(args[0].v, args[1].v), t}
+		case "max":
+			return typed{max(args[0].v, args[1].v), t}
+		case "abs":
+			return typed{abs(args[0].v), t}
+		case "pow":
+			return typed{pow(args[0].v, args[1].v), t}
+		case "month_start_of":
+			return typed{month_start(args[0].v), t}
+		case "month_end_of":
+			return typed{month_end(args[0].v), t}
+		}
+	case "aggregate":
+		return ev.aggregate(node)
+	case "if":
+		// §56 (E-0180, DECISION-0270): чистое data-условие, ветвь вычисляется лениво.
+		if ev.dataCond(field(node, "condition"), e) {
+			return ev.evalTerm(field(node, "then"), e)
+		}
+		return ev.evalTerm(field(node, "else"), e)
+	}
+	refuse("узел терма вне среза раннера: " + str(node["kind"]))
+	return typed{}
+}
+
+type keyed struct {
+	key string
+	val typed
+}
+
+// Материализация §52.1: элементы в порядке канонических байтов, distinct — множество.
+func (ev *evaluation) materialize(comp map[string]interface{}) []typed {
+	if str(comp["kind"]) != "comprehension" {
+		refuse("aggregate.input вне среза раннера")
+	}
+	if len(list(comp, "binders")) > 0 {
+		refuse("связки comprehension вне среза раннера")
+	}
+	var atoms, guards []map[string]interface{}
+	flatten(field(comp, "generator"), &atoms, &guards)
+	if len(atoms) == 0 {
+		refuse("тело без перебираемых атомов вне среза генератора")
+	}
+	for _, a := range atoms {
+		if str(a["polarity"]) != "positive" {
+			refuse("отрицательный литерал в теле вне L0-среза")
+		}
+		params, ok := ev.m.PARAMS[str(a["predicate"])]
+		if !ok {
+			refuse("предикат comprehension не объявлен в пакете: " + str(a["predicate"]))
+		}
+		if len(list(a, "args")) != len(params) {
+			refuse("арность атома тела не совпадает с сигнатурой §189")
+		}
+	}
+	distinct, _ := comp["distinct"].(bool)
+	out := []keyed{}
+	seen := map[string]bool{}
+	element := field(comp, "element")
+	var walk func(i int, e env)
+	walk = func(i int, e env) {
+		if i == len(atoms) {
+			for _, g := range guards {
+				if !cmp(ev.evalTerm(field(g, "left"), e).v, str(g["op"]), ev.evalTerm(field(g, "right"), e).v) {
+					return
+				}
+			}
+			val := ev.evalTerm(element, e)
+			key := literalOf(val)
+			if distinct {
+				if seen[key] {
+					return
+				}
+				seen[key] = true
+			}
+			out = append(out, keyed{key, val})
+			return
+		}
+		a := atoms[i]
+		pred := str(a["predicate"])
+		args := list(a, "args")
+		// L1 (DECISION-0237): только установленные строки (TRUE_ONLY), без BOTH.
+		for _, row := range ev.m.establishedRows(pred) {
+			next := env{}
+			for k, v := range e {
+				next[k] = v
+			}
+			ok := true
+			for j := 0; j < len(row) && ok; j++ {
+				x := args[j].(map[string]interface{})
+				if str(x["kind"]) == "var" {
+					name := str(x["var"])
+					if b, bound := next[name]; !bound {
+						next[name] = ev.slotTyped(pred, j, row[j])
+					} else if !eq(b.v, row[j]) {
+						ok = false
+					}
+				} else if !eq(ev.evalTerm(x, next).v, row[j]) {
+					ok = false
+				}
+			}
+			if ok {
+				walk(i+1, next)
+			}
+		}
+	}
+	walk(0, env{})
+	sort.SliceStable(out, func(i, j int) bool { return out[i].key < out[j].key })
+	vals := make([]typed, len(out))
+	for i, kv := range out {
+		vals[i] = kv.val
+	}
+	return vals
+}
+
+func (ev *evaluation) aggregate(node map[string]interface{}) typed {
+	items := ev.materialize(field(node, "input"))
+	op := str(node["op"])
+	if op == "count" {
+		return typed{dec(fmt.Sprint(len(items))), tINT}
+	}
+	if op == "only" {
+		// §51 (errata E-0256): функциональный lookup. Политика — TYPE_ERROR у
+		// оракула; пусто и два различных значения (канонические байты §208) —
+		// ошибки значения RUNTIME_ERROR, код тот же, что у оракула.
+		if len(field(node, "options")) > 0 {
+			panic(termError{"TYPE_ERROR"})
+		}
+		if len(items) == 0 {
+			panic(termError{"EMPTY_AGGREGATE"})
+		}
+		distinct := map[string]bool{}
+		for _, it := range items {
+			distinct[literalOf(it)] = true
+		}
+		if len(distinct) > 1 {
+			panic(termError{"CARDINALITY_CONFLICT"})
+		}
+		return typed{items[0].v, normKind(items[0].t)}
+	}
+	if op != "sum" && op != "min" && op != "max" {
+		refuse("агрегат вне среза раннера: " + op)
+	}
+	if len(items) == 0 {
+		empty, ok := field(node, "options")["empty"].(map[string]interface{})
+		if !ok {
+			refuse("EMPTY_AGGREGATE: " + op + " над пустой коллекцией без явной empty-политики (§59)")
+		}
+		// `from_literal_term` оракула: политика — LiteralTerm §53; иной узел
+		// даёт TYPE_ERROR раньше сверки вида.
+		if str(empty["kind"]) != "value" {
+			panic(termError{"TYPE_ERROR"})
+		}
+		value := ev.typedArg(empty)
+		// errata E-0195: вид политики обязан совпасть с видом элемента. У оракула
+		// это issue TYPE_ERROR с текстом «aggregate.empty: вид политики integer
+		// не совпадает с видом элемента коллекции money (§59)»; порождённый
+		// модуль сообщений не печатает вовсе, и байтовый контракт среза здесь —
+		// КОД issue, который тот же. До правки коллекция Money с политикой
+		// Integer отвечала `Integer 0` и `COMPUTED` — другой ответ, не меньший.
+		elem := str(field(field(field(node, "input"), "variable"), "type")["name"])
+		if expected, known := emptyElementKinds[elem]; known && normKind(value.t) != expected {
+			panic(termError{"TYPE_ERROR"})
+		}
+		return value
+	}
+	acc := items[0]
+	for _, it := range items[1:] {
+		if !isNumT(acc.t) || normKind(it.t) != normKind(acc.t) {
+			refuse("арифметика вне среза (§58): виды операндов не совпадают у " + op)
+		}
+		if op == "sum" {
+			acc = typed{add(acc.v, it.v), acc.t}
+		} else {
+			c := "gt"
+			if op == "min" {
+				c = "lt"
+			}
+			if cmp(it.v, c, acc.v) {
+				acc = it
+			}
+		}
+	}
+	if !isNumT(acc.t) {
+		refuse("арифметика вне среза (§58): не числовой операнд " + op)
+	}
+	// DECISION-0266: итог агрегата над Natural у оракула — вид `integer`, то есть Integer.
+	return typed{acc.v, normKind(acc.t)}
+}
+
+// Каноническая десятичная запись §18/§208: без хвостовых нулей и minus-zero.
+func canonDec(v Val) string {
+	u, s, _, _, _ := scaled(v)
+	if u.Sign() == 0 {
+		return "0"
+	}
+	x := new(big.Int).Set(u)
+	ten := big.NewInt(10)
+	for s > 0 && new(big.Int).Mod(x, ten).Sign() == 0 {
+		x.Div(x, ten)
+		s--
+	}
+	neg := x.Sign() < 0
+	body := new(big.Int).Abs(x).String()
+	for len(body) < s+1 {
+		body = "0" + body
+	}
+	text := body
+	if s > 0 {
+		text = body[:len(body)-s] + "." + body[len(body)-s:]
+	}
+	if neg && x.Sign() != 0 {
+		return "-" + text
+	}
+	return text
+}
+
+// Каноническая строка §208: экраны как у оракула, не-ASCII как есть.
+func canonStr(s string) string {
+	var b bytes.Buffer
+	b.WriteByte('"')
+	for _, r := range s {
+		switch r {
+		case '"':
+			b.WriteString(`\"`)
+		case '\\':
+			b.WriteString(`\\`)
+		case '\b':
+			b.WriteString(`\b`)
+		case '\f':
+			b.WriteString(`\f`)
+		case '\n':
+			b.WriteString(`\n`)
+		case '\r':
+			b.WriteString(`\r`)
+		case '\t':
+			b.WriteString(`\t`)
+		default:
+			if r < 0x20 {
+				fmt.Fprintf(&b, `\u%04x`, r)
+			} else {
+				b.WriteRune(r)
+			}
+		}
+	}
+	b.WriteByte('"')
+	return b.String()
+}
+
+// Литерал-терм §53 из typed-значения в канонических байтах — то, что печатает оракул.
+func literalOf(x typed) string {
+	switch x.t {
+	case "entity":
+		return `{"id":` + canonStr(x.v.(string)) + `,"kind":"entity_ref"}`
+	case "enum":
+		return `{"id":` + canonStr(string(x.v.(Sym))) + `,"kind":"const_ref"}`
+	case tTEXT:
+		return `{"kind":"value","type":{"name":"` + tTEXT + `"},"value":` + canonStr(x.v.(string)) + `}`
+	case tDATE:
+		return `{"kind":"value","type":{"name":"` + tDATE + `"},"value":` + canonStr(string(x.v.(Date))) + `}`
+	case tINSTANT:
+		return `{"kind":"value","type":{"name":"` + tINSTANT + `"},"value":` + canonStr(string(x.v.(Instant))) + `}`
+	case tMON:
+		m := x.v.(Money)
+		return `{"currency":` + canonStr(m.Cur) + `,"kind":"value","type":{"name":"` + tMON + `"},"value":"` + canonDec(x.v) + `"}`
+	case tDEC:
+		return `{"kind":"value","type":{"name":"` + tDEC + `"},"value":"` + canonDec(x.v) + `"}`
+	case tRAT:
+		q := x.v.(Rational)
+		return `{"kind":"value","type":{"name":"` + tRAT + `"},"value":` + canonStr(q.N.String()+"/"+q.D.String()) + `}`
+	case tBOOL:
+		// Исход сравнения §57 — JSON-булево; ключи по порядку §208.
+		v := "false"
+		if x.v.(bool) {
+			v = "true"
+		}
+		return `{"kind":"value","type":{"name":"` + tBOOL + `"},"value":` + v + `}`
+	case tQTY:
+		// DECISION-0256 п. 7: канонический Decimal и тег как есть; ключи по порядку §208.
+		return `{"kind":"value","type":{"name":"` + tQTY + `"},"unit":` + canonStr(x.v.(Qty).Unit) + `,"value":"` + canonDec(x.v) + `"}`
+	case tNAT:
+		// DECISION-0266: запись дела хранит тип Natural; вычисленное целое — всегда Integer.
+		u, s, _, _, _ := scaled(x.v)
+		return `{"kind":"value","type":{"name":"` + tNAT + `"},"value":` + new(big.Int).Div(u, p10(s)).String() + `}`
+	case tINT:
+		u, s, _, _, _ := scaled(x.v)
+		if new(big.Int).Mod(u, p10(s)).Sign() != 0 {
+			refuse("Integer с дробной частью в результате")
+		}
+		return `{"kind":"value","type":{"name":"` + tINT + `"},"value":` + new(big.Int).Div(u, p10(s)).String() + `}`
+	}
+	refuse("вид результата вне среза раннера: " + x.t)
+	return ""
+}
+
+// Канонический JSON §208 значения шаблона с заземлением переменных payload —
+// порт `norms._ground_payload` (DECISION-0242).
+func canonAny(v interface{}, subst map[string]string) string {
+	switch x := v.(type) {
+	case nil:
+		return "null"
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case string:
+		return canonStr(x)
+	case json.Number:
+		return string(x)
+	case []interface{}:
+		parts := make([]string, len(x))
+		for i, item := range x {
+			parts[i] = canonAny(item, subst)
+		}
+		return "[" + strings.Join(parts, ",") + "]"
+	case map[string]interface{}:
+		if x["kind"] == "var" {
+			if name, ok := x["var"].(string); ok {
+				if s, ok := subst[name]; ok {
+					return s
+				}
+			}
+		}
+		fields := map[string]string{}
+		for k, item := range x {
+			fields[k] = canonAny(item, subst)
+		}
+		return canonObject(fields)
+	}
+	refuse("значение payload вне среза раннера")
+	return ""
+}
+
+func canonObject(fields map[string]string) string {
+	keys := make([]string, 0, len(fields))
+	for k := range fields {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	parts := make([]string, len(keys))
+	for i, k := range keys {
+		parts[i] = canonStr(k) + ":" + fields[k]
+	}
+	return "{" + strings.Join(parts, ",") + "}"
+}
+
+// Вопрос `positions` (DECISION-0242 K4): позиции без id и доказательства.
+// Обход запроса судье §47.3 (DECISION-0274): переводы термов раннера для рантайма;
+// множества сущностей и текстов дела обходом не двигаются.
+func queryTail(qid string) string {
+	if i := strings.LastIndex(qid, ":"); i >= 0 {
+		return qid[i+1:]
+	}
+	return qid
+}
+
+func (ev *evaluation) judgmentRequestsFor(status string, conflict bool) []map[string]interface{} {
+	generic := decodeGeneric(ev.queryRaw)
+	goal := field(generic, "literal")
+	if goal == nil {
+		return nil
+	}
+	if _, ok := goal["polarity"]; !ok {
+		goal["polarity"] = "positive"
+	}
+	return buildRequests(ev.m.judgmentModel(), judgmentBlockers(ev.m.judgmentModel(), ev.hooks, goal, status, conflict), queryTail(str(generic["queryId"])))
+}
+
+func effectiveContext(kase map[string]interface{}) map[string]interface{} {
+	raw := map[string]interface{}{}
+	for k, v := range field(kase, "context") {
+		raw[k] = v
+	}
+	profiles := field(kase, "contextProfiles")
+	parent, _ := raw["extends"].(string)
+	delete(raw, "extends")
+	chain, seen := []string{}, map[string]bool{}
+	for current := parent; current != ""; {
+		if seen[current] {
+			refuse("CONTEXT_PROFILE_CYCLE: цикл наследования профилей (§89.1)")
+		}
+		prof, ok := profiles[current].(map[string]interface{})
+		if !ok {
+			refuse("CONTEXT_PROFILE_MISSING: профиль не определён (§89.1)")
+		}
+		seen[current] = true
+		chain = append(chain, current)
+		current, _ = prof["extends"].(string)
+	}
+	effective := map[string]interface{}{}
+	for i := len(chain) - 1; i >= 0; i-- {
+		for k, v := range field(profiles[chain[i]].(map[string]interface{}), "fields") {
+			effective[k] = v
+		}
+	}
+	for k, v := range raw {
+		effective[k] = v
+	}
+	return effective
+}
+
+func (ev *evaluation) keyConflictBlocks(predicate string) bool {
+	tainted := ev.m.keyConflictPredicates()
+	waiting := make([]string, 0, len(tainted))
+	for source := range tainted {
+		waiting = append(waiting, source)
+	}
+	for len(waiting) != 0 {
+		source := waiting[len(waiting)-1]
+		waiting = waiting[:len(waiting)-1]
+		for _, consumer := range ev.m.KEY_READERS[source] {
+			if !tainted[consumer] {
+				tainted[consumer] = true
+				waiting = append(waiting, consumer)
+			}
+		}
+	}
+	return tainted[predicate]
+}
+
+// Политика §86 и снимок §85 дела до вывода (DECISION-0245 п. 4): порт
+// `engine._resolve_deadline_policy` и `engine._calendar_snapshot`.
+func (ev *evaluation) calendarSetup() {
+	semver, policies, snapshots, ok := ev.m.calendarEnv()
+	if !ok {
+		return
+	}
+	kase := decodeGeneric(ev.caseRaw)
+	var policy map[string]interface{}
+	if ref, present := effectiveContext(kase)["deadlinePolicy"]; present && ref != nil {
+		if strings.HasPrefix(semver, "0.1") {
+			obj, isObj := ref.(map[string]interface{})
+			if !isObj {
+				refuse("case.context.deadlinePolicy вне среза раннера (§86)")
+			}
+			policy = obj
+		} else if name, isStr := ref.(string); !isStr {
+			refuse("case.context.deadlinePolicy: в 0.2 ожидался DeadlinePolicyRef (DECISION-0111 §2.9)")
+		} else if node, found := policies[name].(map[string]interface{}); !found {
+			refuse("case.context.deadlinePolicy: ссылка не разрешена в закреплённом CLIR (§86)")
+		} else {
+			policy = node
+		}
+	}
+	selected, _ := field(kase, "options")["calendarSnapshot"].(string)
+	var snapshot *Snapshot
+	if selected != "" {
+		for i := range snapshots {
+			if snapshots[i].ID == selected {
+				snapshot = &snapshots[i]
+			}
+		}
+		if snapshot == nil {
+			refuse("MISSING_CALENDAR: calendar_snapshot не объявлен в программе (§85, §168.2)")
+		}
+	} else if len(snapshots) >= 2 {
+		refuse("AMBIGUOUS_CALENDAR: в программе несколько calendar_snapshot без выбора (§85, §168.2)")
+	} else if len(snapshots) == 1 {
+		snapshot = &snapshots[0]
+	}
+	ev.m.ctx.setCalendar(policy, snapshot)
+}
+
+// E-0105: код ошибки терма → статус результата (`whynot.TERM_ERROR_STATUS`);
+// код вне таблицы — RUNTIME_ERROR; старшинство — `TERM_ERROR_PRECEDENCE`.
+var termErrorStatusOf = map[string]string{"MISSING_POLICY": "MISSING_POLICY", "DEADLINE_POLICY_INVALID": "MISSING_POLICY",
+	"MISSING_CALENDAR": "MISSING_INPUT", "CALENDAR_DATASET_INVALID": "MISSING_INPUT",
+	"CALENDAR_DATASET_HASH_MISMATCH": "MISSING_INPUT", "CALENDAR_OUT_OF_RANGE": "MISSING_INPUT", "TYPE_ERROR": "TYPE_ERROR",
+	"CURRENCY_MISMATCH": "TYPE_ERROR", "DIMENSION_MISMATCH": "TYPE_ERROR", "DATE_INSTANT_MISMATCH": "TYPE_ERROR",
+	"RESOURCE_LIMIT": "RESOURCE_LIMIT", "OPAQUE_NON_EXECUTABLE": "NON_EXECUTABLE", "NON_EXHAUSTIVE_MATCH": "NON_EXECUTABLE",
+	"UNKNOWN_FUNCTION": "NON_EXECUTABLE", "NON_EXECUTABLE_FUNCTION_RECURSION": "NON_EXECUTABLE"}
+var termErrorPrecedence = []string{"MISSING_INPUT", "MISSING_POLICY", "NON_EXECUTABLE", "EXTERNAL_UNAVAILABLE",
+	"TYPE_ERROR", "RUNTIME_ERROR", "RESOURCE_LIMIT"}
+
+var outcomeCodes = map[string]bool{"PRIORITY_CONFLICT": true, "INTERPRETATION_REQUIRED": true, "TYPE_ERROR": true,
+	"RESOURCE_LIMIT": true, "CONFLICTED_INPUTS": true, "SOURCE_RESOLUTION_FAILED": true}
+
+// Статус результата, зависящего от упавшего правила: NEITHER — статус кода (E-0105),
+// иная истинность — итог §181.2; смешанные коды — порядок issue, которого раннер
+// не воспроизводит, — названный отказ. `pred` пуст — носители TYPE_ERROR не читаются.
+func (ev *evaluation) ruleErrorStatus(pred, truth string) string {
+	te := ev.termErrorStatus()
+	codes := map[string]bool{}
+	if te != "" {
+		for c := range ev.lastTermCodes {
+			codes[c] = true
+		}
+	}
+	ct := ""
+	if pred != "" {
+		ct = ev.carrierTypeError(pred)
+	}
+	if te == "" && ct == "" {
+		return ""
+	}
+	if truth == "NEITHER" {
+		if te != "" {
+			return te
+		}
+		return ct
+	}
+	if ct != "" {
+		codes["TYPE_ERROR"] = true
+	}
+	kept := []string{}
+	for c := range codes {
+		if outcomeCodes[c] {
+			kept = append(kept, c)
+		}
+	}
+	if len(kept) == 0 {
+		return "NON_EXECUTABLE"
+	}
+	if len(kept) == len(codes) && len(kept) == 1 {
+		return kept[0]
+	}
+	refuse("статус итога §181.2 зависит от порядка issue вне среза раннера")
+	return ""
+}
+
+func (ev *evaluation) carrierTypeError(pred string) string {
+	if len(ev.typeErrorPredicates) == 0 {
+		return ""
+	}
+	seen := map[string]bool{}
+	var walk func(string) bool
+	walk = func(p string) bool {
+		if seen[p] {
+			return false
+		}
+		seen[p] = true
+		if ev.typeErrorPredicates[p] {
+			return true
+		}
+		for _, c := range ev.m.CARRIER_EDGES[p] {
+			if walk(c) {
+				return true
+			}
+		}
+		return false
+	}
+	if walk(pred) {
+		return "TYPE_ERROR"
+	}
+	return ""
+}
+
+// Порт `whynot.term_error_blockers` + `term_error_status`: правила с совместимой
+// головой, их ошибки терма и конъюнкты без опоры — вглубь.
+func (ev *evaluation) termErrorStatus() string {
+	rules, consts, seen, ok := ev.m.backchainEnv()
+	if !ok {
+		return ""
+	}
+	byRule := map[string][]string{}
+	for k := range seen {
+		at := strings.LastIndex(k, "|")
+		name, code := k[:at], k[at+1:]
+		if code != "MISSING_PARAMETER_VALUE" {
+			byRule[name] = append(byRule[name], code)
+		}
+	}
+	if len(byRule) == 0 {
+		return ""
+	}
+	index := map[string][]map[string]interface{}{}
+	for _, x := range rules {
+		r := x.(map[string]interface{})
+		pred := str(field(r, "head")["predicate"])
+		index[pred] = append(index[pred], r)
+	}
+	canon := func(v interface{}) string { return canonAny(v, map[string]string{}) }
+	argsOf := func(lit map[string]interface{}) []interface{} { return list(lit, "args") }
+	kindOf := func(a interface{}) string { return str(a.(map[string]interface{})["kind"]) }
+	varOf := func(a interface{}) string { return str(a.(map[string]interface{})["var"]) }
+	polarity := func(lit map[string]interface{}) string {
+		if p := str(lit["polarity"]); p != "" {
+			return p
+		}
+		return "positive"
+	}
+	compatible := func(head, target map[string]interface{}) map[string]interface{} {
+		if polarity(head) != polarity(target) {
+			return nil
+		}
+		ha, ga := argsOf(head), argsOf(target)
+		if len(ha) != len(ga) {
+			return nil
+		}
+		subst := map[string]interface{}{}
+		for i := range ha {
+			h, g := ha[i], ga[i]
+			if kindOf(g) == "var" {
+				continue
+			}
+			switch kindOf(h) {
+			case "var":
+				if prev, bound := subst[varOf(h)]; bound && canon(prev) != canon(g) {
+					return nil
+				}
+				subst[varOf(h)] = g
+			case "entity_ref", "const_ref", "value":
+				if canon(h) != canon(g) {
+					return nil
+				}
+			}
+		}
+		return subst
+	}
+	mirror := map[string]string{"TRUE_ONLY": "FALSE_ONLY", "FALSE_ONLY": "TRUE_ONLY", "BOTH": "BOTH", "NEITHER": "NEITHER"}
+	truth := func(lit map[string]interface{}) string {
+		savedE, savedT := map[string]bool{}, map[string]bool{}
+		for k := range ev.entities {
+			savedE[k] = true
+		}
+		for k := range ev.texts {
+			savedT[k] = true
+		}
+		defer func() { ev.entities, ev.texts = savedE, savedT }()
+		row := []Val{}
+		for _, a := range argsOf(lit) {
+			b, _ := json.Marshal(a)
+			var aj argJSON
+			if err := json.Unmarshal(b, &aj); err != nil {
+				panic(err)
+			}
+			row = append(row, ev.toVal(aj))
+		}
+		st := ev.m.truthOf(str(lit["predicate"]), row)
+		if polarity(lit) == "negative" {
+			return mirror[st]
+		}
+		return st
+	}
+	found, visited := map[string]bool{}, map[string]bool{}
+	var walk func(target map[string]interface{})
+	walk = func(target map[string]interface{}) {
+		key := canon(target)
+		if visited[key] {
+			return
+		}
+		visited[key] = true
+		for _, r := range index[str(target["predicate"])] {
+			subst := compatible(field(r, "head"), target)
+			if subst == nil {
+				continue
+			}
+			if w, isMap := r["window"].(map[string]interface{}); isMap {
+				start, _ := w["start"].(string)
+				end, _ := w["end"].(string)
+				if (start != "" && ev.m.ctx.legalTime() < start) || (end != "" && ev.m.ctx.legalTime() >= end) {
+					continue
+				}
+			}
+			for _, c := range byRule[str(r["name"])] {
+				found[c] = true
+			}
+			for _, cj := range list(r, "body") {
+				lit := cj.([]interface{})[1].(map[string]interface{})
+				if str(lit["kind"]) != "literal" {
+					continue // DECISION-0274: гарды в backchain — только для пути судьи
+				}
+				args := argsOf(lit)
+				wildcard, unbound := false, false
+				computed := func(a interface{}) bool {
+					switch kindOf(a) {
+					case "binary", "call", "if", "let", "match":
+						return true
+					}
+					return false
+				}
+				for _, a := range args {
+					if kindOf(a) == "wildcard" {
+						wildcard = true
+					}
+					// DECISION-0270: вычисляемый аргумент не заземляется обходом —
+					// как несвязанная переменная, конъюнкт идёт вглубь без оценки.
+					if computed(a) {
+						unbound = true
+					}
+					if kindOf(a) == "var" {
+						if v, bound := subst[varOf(a)]; !bound || computed(v) {
+							unbound = true
+						}
+					}
+				}
+				if wildcard {
+					continue
+				}
+				next := map[string]interface{}{}
+				for k, v := range lit {
+					next[k] = v
+				}
+				ground := []interface{}{}
+				for _, a := range args {
+					if kindOf(a) == "var" {
+						if v, bound := subst[varOf(a)]; bound {
+							ground = append(ground, v)
+							continue
+						}
+					}
+					ground = append(ground, a)
+				}
+				next["args"] = ground
+				if unbound {
+					walk(next)
+					continue
+				}
+				if truth(next) == "NEITHER" {
+					walk(next)
+				}
+			}
+		}
+	}
+	goal := map[string]interface{}{}
+	for k, v := range field(decodeGeneric(ev.queryRaw), "literal") {
+		goal[k] = v
+	}
+	derefd := []interface{}{}
+	for _, a := range list(goal, "args") {
+		m := a.(map[string]interface{})
+		if kindOf(a) == "const_ref" {
+			if v, isConst := consts[str(m["id"])]; isConst {
+				derefd = append(derefd, v)
+				continue
+			}
+		}
+		derefd = append(derefd, a)
+	}
+	goal["args"] = derefd
+	walk(goal)
+	ev.lastTermCodes = map[string]bool{}
+	for c := range found {
+		ev.lastTermCodes[c] = true
+	}
+	for _, st := range termErrorPrecedence {
+		for c := range found {
+			mapped, known := termErrorStatusOf[c]
+			if !known {
+				mapped = "RUNTIME_ERROR"
+			}
+			if mapped == st {
+				return st
+			}
+		}
+	}
+	return ""
+}
+
+func (ev *evaluation) run() string {
+	var kase struct {
+		Context struct {
+			LegalTime    string  `json:"legalTime"`
+			DecisionTime *string `json:"decisionTime"`
+		} `json:"context"`
+		Assertions []struct {
+			Literal  litJSON         `json:"literal"`
+			Valid    json.RawMessage `json:"valid"`
+			Judgment json.RawMessage `json:"judgment"`
+		} `json:"assertions"`
+	}
+	var query struct {
+		Kind      string  `json:"kind"`
+		QueryID   string  `json:"queryId"`
+		Literal   litJSON `json:"literal"`
+		Predicate string  `json:"predicate"`
+	}
+	mustUnmarshal(ev.caseRaw, &kase)
+	mustUnmarshal(ev.queryRaw, &query)
+	ev.m.ctx.setLegalTime(kase.Context.LegalTime)
+	if kase.Context.DecisionTime != nil {
+		ev.m.setStatusTime((*kase.Context.DecisionTime)[:10])
+	}
+	ev.calendarSetup()
+	ev.m.packageFacts()
+	for _, a := range kase.Assertions {
+		if len(a.Valid) != 0 && string(a.Valid) != "null" {
+			refuse("поле assertion.valid вне среза раннера (§72)")
+		}
+		if a.Literal.Polarity != "positive" && (LAYER != "L1" || a.Literal.Polarity != "negative") {
+			refuse("§113: отрицательный факт вне L0-среза")
+		}
+		if a.Literal.Predicate == "urn:law:std#incompatible" {
+			if _, ok := ev.m.normPositions(); ok {
+				// §105.1: явная несовместимость позиций — конфликт вне среза (DECISION-0242 K5).
+				refuse("конфликт позиций §105.1 (incompatible) вне среза раннера (DECISION-0242 K5)")
+			}
+		}
+		if !ev.wellTyped(a.Literal) {
+			continue
+		}
+		if _, ok := ev.m.PARAMS[a.Literal.Predicate]; !ok {
+			continue
+		}
+		// §47.3.1 (E-0089, DECISION-0274): ответ судьи не от того органа или не по форме — не принят.
+		if len(a.Judgment) != 0 && string(a.Judgment) != "null" {
+			var judgment map[string]interface{}
+			if err := json.Unmarshal(a.Judgment, &judgment); err != nil {
+				panic(err)
+			}
+			if rejected := judgmentAnswer(ev.m.judgmentModel(), a.Literal.Predicate, judgment); rejected != "" {
+				ev.issues = append(ev.issues, rejected)
+				continue
+			}
+		}
+		row := make([]Val, len(a.Literal.Args))
+		for i, x := range a.Literal.Args {
+			row[i] = ev.toVal(x)
+		}
+		if a.Literal.Polarity == "negative" {
+			ev.m.registerNegative(a.Literal.Predicate, row)
+		} else {
+			ev.m.register(a.Literal.Predicate, row)
+		}
+	}
+	ev.m.saturate()
+	// DECISION-0239 G3: ошибки значения агрегатов в правилах — issues модели.
+	ev.issues = append(ev.issues, ev.m.ruleIssues()...)
+	// DECISION-0242: диагностики эффектов полномочий §127–§128.
+	ev.issues = append(ev.issues, ev.m.normIssues()...)
+	for n := ev.m.keyConflicts(); n > 0; n-- {
+		ev.issues = append(ev.issues, "KEY_CONFLICT")
+	}
+	issuesJSON, _ := json.Marshal(ev.issues)
+	qid := canonStr(query.QueryID)
+	if query.Kind == "rows" && ev.api {
+		return ev.rowsJSON(query.Predicate, qid, string(issuesJSON))
+	}
+	if query.Kind == "collect" || query.Kind == "term" {
+		// Числа — json.Number: через float64 длинное целое потеряло бы знаки.
+		generic := decodeGeneric(ev.queryRaw)
+		if query.Kind == "collect" {
+			parts := []string{}
+			for _, e := range ev.materialize(field(generic, "comprehension")) {
+				if s, ok := e.v.(string); ok && strings.HasPrefix(s, "urn:position:") {
+					refuse("позиция в элементе коллекции вне среза раннера (DECISION-0242 K4)")
+				}
+				parts = append(parts, literalOf(e))
+			}
+			return `{"queryId":` + qid + `,"resultKind":"COLLECTION","value":[` + strings.Join(parts, ",") + `],"evaluationStatus":"COMPUTED","issues":` + string(issuesJSON) + `}`
+		}
+		value, code := func() (s string, code string) {
+			defer func() {
+				if rec := recover(); rec != nil {
+					if e, ok := rec.(termError); ok {
+						code = e.code
+						return
+					}
+					panic(rec)
+				}
+			}()
+			return literalOf(ev.evalTerm(field(generic, "term"), env{})), ""
+		}()
+		if code != "" {
+			// §58/§175 (DECISION-0252 п. 8): ошибка значения вопроса — без значения;
+			// статус по таблице `queries.query_calc`: несовместимость видов —
+			// TYPE_ERROR, прочее — RUNTIME_ERROR.
+			status := "RUNTIME_ERROR"
+			switch code {
+			case "TYPE_ERROR", "CURRENCY_MISMATCH", "DIMENSION_MISMATCH", "DATE_INSTANT_MISMATCH":
+				status = "TYPE_ERROR"
+			}
+			failed, _ := json.Marshal(append(append([]string{}, ev.issues...), code))
+			return `{"queryId":` + qid + `,"resultKind":"DATA","evaluationStatus":"` + status + `","issues":` + string(failed) + `}`
+		}
+		return `{"queryId":` + qid + `,"resultKind":"DATA","value":` + value + `,"evaluationStatus":"COMPUTED","issues":` + string(issuesJSON) + `}`
+	}
+	if query.Kind != "truth" {
+		refuse("вид запроса вне среза раннера: " + query.Kind)
+	}
+	for _, x := range query.Literal.Args {
+		if x.Kind == "entity_ref" && strings.HasPrefix(x.ID, "urn:position:") {
+			refuse("позиция в аргументе вопроса вне среза раннера (DECISION-0242 K4)")
+		}
+	}
+	if LAYER == "L1" {
+		// §62/§63: статус атома по опорам обеих полярностей; отрицательный
+		// вопрос зеркалит стороны; несогласованный по сигнатуре вопрос — NEITHER.
+		status := "NEITHER"
+		evaluation := "COMPUTED"
+		conflict := false
+		if ev.queryTyped(query.Literal) {
+			want := make([]Val, len(query.Literal.Args))
+			for i, x := range query.Literal.Args {
+				want[i] = ev.toVal(x)
+			}
+			status = ev.m.truthOf(query.Literal.Predicate, want)
+			conflict = ev.m.blockedEffect(query.Literal.Predicate, want)
+		}
+		if query.Literal.Polarity == "negative" {
+			status = map[string]string{"TRUE_ONLY": "FALSE_ONLY", "FALSE_ONLY": "TRUE_ONLY", "BOTH": "BOTH", "NEITHER": "NEITHER"}[status]
+		}
+		// §47.3 (DECISION-0274): судьи по лестнице §175 — конфликт старше судьи, судья старше ошибки терма.
+		requests := ev.judgmentRequestsFor(status, conflict)
+		if conflict {
+			// §127: эффект заперт непобеждённой парой Power/Immunity.
+			evaluation = "UNRESOLVED_NORMATIVE_CONFLICT"
+		} else if ev.keyConflictBlocks(query.Literal.Predicate) {
+			evaluation = "NON_EXECUTABLE"
+		} else if len(requests) > 0 {
+			evaluation = "REQUIRES_JUDGMENT"
+		} else if st := ev.ruleErrorStatus(query.Literal.Predicate, status); st != "" {
+			// E-0243 §181.2: носитель TYPE_ERROR блокирует своих читателей и у L1, как у py и ts.
+			evaluation = st
+		} else if status == "NEITHER" {
+			// E-0105 (§175/§185): NEITHER над ошибкой терма правила-кандидата.
+			if st := ev.termErrorStatus(); st != "" {
+				evaluation = st
+			}
+		}
+		if requests == nil {
+			requests = []map[string]interface{}{}
+		}
+		out, _ := json.Marshal(map[string]interface{}{"queryId": query.QueryID,
+			"truthStatus": status, "evaluationStatus": evaluation, "judgmentRequests": requests, "issues": ev.issues})
+		return string(out)
+	}
+	// Ключ атома у оракула §208 включает ТИП значения: запрос с Integer к
+	// утверждению Decimal той же величины атома не находит — NEITHER без issue.
+	hit := false
+	rows := [][]Val{}
+	want := []Val{}
+	if ev.queryTyped(query.Literal) {
+		rows = ev.m.TABLES[query.Literal.Predicate]
+		want = make([]Val, len(query.Literal.Args))
+		for i, x := range query.Literal.Args {
+			want[i] = ev.toVal(x)
+		}
+	}
+	for _, row := range rows {
+		if len(row) != len(want) {
+			continue
+		}
+		all := true
+		for i := range row {
+			if !eq(row[i], want[i]) {
+				all = false
+				break
+			}
+		}
+		if all {
+			hit = true
+			break
+		}
+	}
+	// Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+	// §47.3 (DECISION-0274): судьи у модели L0 — тот же обход по backchain.
+	status := "NEITHER"
+	if hit {
+		status = "TRUE_ONLY"
+	}
+	requests := ev.judgmentRequestsFor(status, false)
+	evaluation := "COMPUTED"
+	if ev.keyConflictBlocks(query.Literal.Predicate) {
+		evaluation = "NON_EXECUTABLE"
+	} else if len(requests) > 0 {
+		evaluation = "REQUIRES_JUDGMENT"
+	} else if st := ev.ruleErrorStatus(query.Literal.Predicate, status); st != "" {
+		evaluation = st
+	}
+	if requests == nil {
+		requests = []map[string]interface{}{}
+	}
+	out, _ := json.Marshal(map[string]interface{}{"queryId": query.QueryID,
+		"truthStatus": status, "evaluationStatus": evaluation, "judgmentRequests": requests, "issues": ev.issues})
+	return string(out)
+}
+
+// Внутренний вид API `rows` (DECISION-0423 §2.1): установленные строки вопроса
+// литерал-термами §53 в порядке канонических байтов; статус вычисления — как у
+// вопроса о том же отношении (конфликт ключа блокирует читателей, E-0242).
+func (ev *evaluation) rowsJSON(pred, qid, issuesJSON string) string {
+	if _, ok := ev.m.PARAMS[pred]; !ok {
+		refuse("предикат rows не объявлен в пакете: " + pred)
+	}
+	var src [][]Val
+	if LAYER == "L1" {
+		src = ev.m.establishedRows(pred)
+	} else {
+		src = ev.m.TABLES[pred]
+	}
+	rows := []string{}
+	for _, r := range src {
+		cells := make([]string, len(r))
+		for col, v := range r {
+			cells[col] = literalOf(ev.slotTyped(pred, col, v))
+		}
+		rows = append(rows, "["+strings.Join(cells, ",")+"]")
+	}
+	sort.Strings(rows)
+	evaluation := "COMPUTED"
+	if ev.keyConflictBlocks(pred) {
+		evaluation = "NON_EXECUTABLE"
+	}
+	return `{"queryId":` + qid + `,"resultKind":"COLLECTION","rows":[` + strings.Join(rows, ",") +
+		`],"evaluationStatus":"` + evaluation + `","judgmentRequests":[],"issues":` + issuesJSON + `}`
+}