arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/py/runtime.py

@@ -0,0 +1,1634 @@
+"""Рантайм L0 для Python. Тот же контракт, что у runtime.ts и runtime.go:
+точная десятичная арифметика §58, деньги с валютой, названный режим
+округления, календарный день, член перечисления."""
+
+
+import builtins as _b
+import contextvars as _cv
+import re
+import datetime as _dt
+
+
+class Refused(Exception):
+    """Названный отказ рантайма: то, что срез не считает, а не сбой.
+
+    Раннер печатает его как JSON с кодом выхода 3. Любое другое исключение —
+    крах, и ворота обязаны его отличать: молчаливое «не смог» и «упал»
+    неразличимы по одному ненулевому коду."""
+
+
+class Dec:
+    __slots__ = ("u", "s")
+
+    def __init__(self, u: int, s: int):
+        self.u, self.s = u, s
+
+
+class Money(Dec):
+    __slots__ = ("cur",)
+
+    def __init__(self, u: int, s: int, cur: str):
+        super().__init__(u, s)
+        self.cur = cur
+
+
+class Qty(Dec):
+    """Quantity §49 v1 (DECISION-0256 п. 5): точное десятичное и тег единицы —
+    байты записи; реестра единиц и алиасов §49.2 здесь нет. Не Money: у ключа
+    и у сравнения свой вид, 1 KZT денег и величина 1 [KZT] — разные значения."""
+    __slots__ = ("unit",)
+
+    def __init__(self, u: int, s: int, unit: str):
+        super().__init__(u, s)
+        self.unit = unit
+
+
+class Rat:
+    """Rational §35 (DECISION-0252 п. 6): несократимая дробь на целых
+    произвольной длины, знаменатель положителен, ноль — 0/1. Не Dec: у ключа
+    строки и у сравнения свой вид, 2/1 и Decimal 2 — разные значения §48."""
+    __slots__ = ("n", "d")
+
+    def __init__(self, n: int, d: int):
+        if d == 0:
+            raise TermError("DIVISION_BY_ZERO")
+        if d < 0:
+            n, d = -n, -d
+        g = _gcd(n, d) or 1
+        self.n, self.d = n // g, d // g
+
+
+_DATE_RE = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}\Z")
+_INSTANT_RE = re.compile(r"([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})\Z")
+
+
+def _date_parts(raw):
+    if not isinstance(raw, str) or not _DATE_RE.fullmatch(raw):
+        raise TermError("TYPE_ERROR")
+    try:
+        return _dt.date.fromisoformat(raw)
+    except ValueError as exc:
+        raise TermError("TYPE_ERROR") from exc
+
+
+class Date:
+    """Strict ASCII Gregorian Date (§82.2)."""
+    __slots__ = ("v",)
+
+    def __init__(self, v: str):
+        _date_parts(v)
+        self.v = v
+
+
+def date(lit: str) -> Date:
+    return Date(lit)
+
+
+class Instant:
+    """Keep the record for atom identity; compare the exact moment (§82.2)."""
+    __slots__ = ("v",)
+
+    def __init__(self, v: str):
+        _moment_text(v)
+        self.v = v
+
+
+def instant(lit: str) -> Instant:
+    return Instant(lit)
+
+
+def _moment_text(raw):
+    m = _INSTANT_RE.fullmatch(raw) if isinstance(raw, str) else None
+    if not m:
+        raise TermError("TYPE_ERROR")
+    day = _date_parts(m[1])
+    h, mi, sec = map(int, (m[2], m[3], m[4]))
+    off = m[6]
+    if h > 23 or mi > 59 or sec > 59:
+        raise TermError("TYPE_ERROR")
+    offset = 0
+    if off != "Z":
+        oh, om = int(off[1:3]), int(off[4:6])
+        if oh > 23 or om > 59:
+            raise TermError("TYPE_ERROR")
+        offset = (-1 if off[0] == "-" else 1) * (oh * 3600 + om * 60)
+    seconds = (day.toordinal() - _dt.date(1970, 1, 1).toordinal()) * 86400 + h * 3600 + mi * 60 + sec - offset
+    return seconds, (m[5] or "").rstrip("0")
+
+
+def _moment(value: Instant):
+    return _moment_text(value.v)
+
+
+def _moment_pair(op: str, a: Instant, b: Instant):
+    return _moment(a), _moment(b)
+
+
+def validate_temporal_case(case):
+    for i, assertion in enumerate(case.get("assertions") or []):
+        if "valid" not in assertion:
+            continue
+        interval = assertion["valid"]
+        if not isinstance(interval, dict):
+            raise Refused(f"TEMPORAL_BOUND_INVALID: request:/case/assertions/{i}/valid")
+        for side in ("start", "end"):
+            if side not in interval:
+                continue
+            value = interval[side]
+            if value == ("-infinity" if side == "start" else "infinity"):
+                continue
+            try:
+                _date_parts(value) if isinstance(value, str) and _DATE_RE.fullmatch(value) else _moment_text(value)
+            except TermError as exc:
+                raise Refused(f"TEMPORAL_BOUND_INVALID: request:/case/assertions/{i}/valid/{side}") from exc
+
+
+class Sym:
+    """Член перечисления §38 либо иная ссылка `const_ref` без объявления:
+    значение — stable qualified identity, равенство — по ней (§57), порядок не
+    определён. В ключе атома у оракула это узел `const_ref`, не сущность."""
+    __slots__ = ("id",)
+
+    def __init__(self, id: str):                              # noqa: A002
+        self.id = id
+
+
+def sym(id: str) -> Sym:                                      # noqa: A002
+    return Sym(str(id))
+
+
+def dec(lit: str) -> Dec:
+    return lit_dec(lit)
+
+
+def money(lit: str, cur: str) -> Money:
+    d = dec(lit)
+    return Money(d.u, d.s, cur)
+
+
+def rat_term(lit) -> Rat:
+    """Литерал Rational в вычислимом терме вопроса `term`: разбор оракула
+    (`values.from_literal_term`) — запись `n/d` с целыми частями по лексике
+    §208 (E-0203), сократимая и со знаком в знаменателе нормализуется; не
+    `n/d` — TYPE_ERROR, знаменатель 0 — DIVISION_BY_ZERO. Каноничность §168.1
+    требуется от записей дела и вопроса `truth`, не от операнда (ERR-E0005)."""
+    return lit_rat_term(lit)
+
+
+def qty(lit: str, unit: str) -> Qty:
+    """Величина §49: значение и тег единицы как записаны."""
+    d = dec(lit)
+    return Qty(d.u, d.s, str(unit))
+
+
+def rat(lit) -> Rat:
+    """Каноническая запись `n/d` (§168.1): иная — названный отказ, а не молчаливое
+    сокращение — оракул хранит запись как есть, и сокращённая дала бы другой ответ."""
+    text = lit_text(lit)
+    num, sep, den = text.partition("/")
+    if not sep or not (_FRACTION_PART_LEXIS.match(num) and _FRACTION_PART_LEXIS.match(den)):
+        raise Refused("§168.1: запись Rational не n/d: " + text)
+    n, d = int(num), int(den)
+    if d <= 0 or _gcd(n, d) != 1 or f"{n}/{d}" != text:
+        raise Refused("§168.1: неканоническая запись Rational: " + text)
+    return Rat(n, d)
+
+
+# --- сырое поле литерала §208 ----------------------------------------------
+# Правило одно на три цели (errata E-0197, E-0202, E-0203): сырое поле литерала
+# читается НЕ средствами языка цели, а по грамматике §208. `int()`, `Decimal()`
+# и `Fraction()` Python принимают пробелы, `_`, юникодную цифру и `Infinity`;
+# `Number()`/`parseFloat` JavaScript принимают `1e2` и `Infinity` и теряют
+# точность на i64; `strconv`/`math/big` Go имеют свои допуски. Норма у всех
+# одна, поэтому алфавит назван явно и одинаково.
+
+#: §18/§208 (errata E-0203): лексика ЗАПИСИ десятичного значения — дословный
+#: порт `lawref/values.py::_DECIMAL_LEXIS`. Экспонента, ведущие и хвостовые
+#: нули, знак `+`, `.5` и `5.` остаются законной записью входа и нормализуются;
+#: сужены ровно пробельный символ, `_`, не-ASCII цифра и `Infinity`/`NaN`.
+#: Якорь `\Z`, а не `$`: Python-овый `$` пропускает хвостовой перевод строки.
+_DECIMAL_LEXIS = re.compile(r"^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?\Z")
+
+#: §35/§208 (errata E-0203): лексика ЦЕЛОГО внутри записи `<n>/<d>`.
+_FRACTION_PART_LEXIS = re.compile(r"^[+-]?[0-9]+\Z")
+
+#: §208 (errata E-0202): знаковый 64-битный носитель JSON-числа канона.
+I64_MIN, I64_MAX = -(2 ** 63), 2 ** 63 - 1
+
+#: Канон §208 отвергает JSON-float и целое вне i64 ОТКАЗОМ СОБРАТЬ ДОКУМЕНТ
+#: (error-объект §172), а не issue. У порождённого модуля канала error-объекта
+#: нет — профиль `core-executable` документа не строит, — поэтому тот же вход
+#: даёт названный отказ раннера: «меньше ответа», а не другой ответ.
+CANON_NUMBER = ("JSON-число вне канона §208 (только целое знакового 64-битного "
+                "диапазона) вне среза раннера")
+
+
+def raw_lit(raw):
+    """Вид JSON-носителя сырого поля литерала и его текст: `s` — JSON-строка,
+    `i` — целое JSON-число канона, `x` — любая другая форма (в том числе
+    отсутствие поля: схема `LiteralTerm` не требует `value`, E-0197)."""
+    if isinstance(raw, str):
+        return "s", raw
+    if isinstance(raw, bool):
+        return "x", ""
+    if isinstance(raw, int):
+        if not (I64_MIN <= raw <= I64_MAX):
+            raise Refused(CANON_NUMBER)
+        return "i", str(raw)
+    if isinstance(raw, float):
+        raise Refused(CANON_NUMBER)
+    return "x", ""
+
+
+def lit_text(raw) -> str:
+    """Поле, чей канон §208 — JSON-строка (`Text`, `Date`, `Instant`,
+    `Rational`, валюта, единица). Порт `values._json_string`: до E-0197 цели
+    приводили к строке ЛЮБОЙ JSON, и литерал без `value` выходил значением
+    `"undefined"` у ts и `""` у go — расхождение в результате, не в тексте."""
+    kind, text = raw_lit(raw)
+    if kind != "s":
+        raise TermError("TYPE_ERROR")
+    return text
+
+
+def lit_int_text(raw) -> str:
+    """Поле, чей канон §208 — целое JSON-число (`Integer`). Порт `values._json_int`."""
+    kind, text = raw_lit(raw)
+    if kind != "i":
+        raise TermError("TYPE_ERROR")
+    return text
+
+
+def lit_dec_text(raw) -> str:
+    """Поле `Decimal`/`Money`/`Quantity`: строка по лексике §208 либо целое
+    JSON-число (запись числом остаётся законной — E-0203, долг п. 3)."""
+    kind, text = raw_lit(raw)
+    if kind == "i":
+        return text
+    if kind != "s" or not _DECIMAL_LEXIS.match(text):
+        raise TermError("TYPE_ERROR")
+    return text
+
+
+def dec_lexis(text: str) -> Dec:
+    """Точное десятичное из записи, уже прошедшей `_DECIMAL_LEXIS`: знак,
+    необязательная экспонента, `.5` и `5.`. Нормализация — как у
+    `Decimal(text)` оракула, чей канон §208 печатает non-exponent форму."""
+    body = text
+    neg = body[:1] == "-"
+    if body[:1] in ("+", "-"):
+        body = body[1:]
+    mant, sep, exp_text = body.partition("e")
+    if not sep:
+        mant, sep, exp_text = body.partition("E")
+    exp = int(exp_text) if sep else 0
+    int_part, _, frac = mant.partition(".")
+    digits = (int_part + frac) or "0"
+    scale = len(frac) - exp
+    unscaled = int(digits)
+    if unscaled == 0 and _b.abs(scale) > 4096:
+        return Dec(0, 0)
+    canonical_scale = scale - (len(digits) - len(digits.rstrip("0")))
+    if unscaled != 0 and (canonical_scale > 4096 or scale < -4096):
+        raise Refused("DECIMAL_EXPANSION_UNAVAILABLE: E-0320 limit 4096")
+    if scale < 0:
+        unscaled *= 10 ** (-scale)
+        scale = 0
+    return Dec(-unscaled if neg else unscaled, scale)
+
+
+def lit_dec(raw) -> Dec:
+    return dec_lexis(lit_dec_text(raw))
+
+
+def lit_int(raw) -> Dec:
+    return Dec(int(lit_int_text(raw)), 0)
+
+
+def lit_money(raw, cur) -> Money:
+    d = lit_dec(raw)
+    return Money(d.u, d.s, lit_text(cur))
+
+
+def lit_qty(raw, unit) -> Qty:
+    d = lit_dec(raw)
+    return Qty(d.u, d.s, lit_text(unit))
+
+
+def lit_rat_term(raw) -> Rat:
+    """Литерал `Rational` вычислимого терма: порт ветви `RATIONAL`
+    `values.from_literal_term` в редакции E-0203 — `<n>/<d>` с частями по
+    `_FRACTION_PART_LEXIS`, сократимая запись нормализуется."""
+    parts = lit_text(raw).split("/")
+    if len(parts) != 2 or not (_FRACTION_PART_LEXIS.match(parts[0])
+                               and _FRACTION_PART_LEXIS.match(parts[1])):
+        raise TermError("TYPE_ERROR")
+    n, d = int(parts[0]), int(parts[1])
+    if d == 0:
+        raise TermError("DIVISION_BY_ZERO")
+    return Rat(n, d)
+
+
+# --- виды ------------------------------------------------------------------
+
+def _is_num(v) -> bool:
+    return isinstance(v, Dec)
+
+
+def _same(a, b, op: str) -> None:
+    """§48/§58: сложение, вычитание, min/max требуют совпадения видов;
+    у денег — и валюты, у величин — и единицы (DECISION-0256: ошибка значения)."""
+    if isinstance(a, Qty) or isinstance(b, Qty):
+        if not (isinstance(a, Qty) and isinstance(b, Qty)):
+            raise TermError("TYPE_ERROR")
+        if a.unit != b.unit:
+            raise TermError("DIMENSION_MISMATCH")
+        return
+    if not (_is_num(a) and _is_num(b)) or isinstance(a, Money) != isinstance(b, Money):
+        raise Refused(f"§58: виды операндов не совпадают: {op}")
+    if isinstance(a, Money) and a.cur != b.cur:
+        raise Refused(f"§58: разные валюты: {op}")
+
+
+def _bounded_coefficient(u, s=0):
+    if u < -(1 << 127) or u >= (1 << 127) or (u and s > 4096):
+        raise Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+    return u
+
+
+def _pair(a, b):
+    s = _b.max(a.s, b.s)
+    x, y = a.u * 10 ** (s - a.s), b.u * 10 ** (s - b.s)
+    _bounded_coefficient(x, s); _bounded_coefficient(y, s)
+    return x, y, s
+
+
+def _make(u: int, s: int, like) -> Dec:
+    _bounded_coefficient(u, s)
+    if isinstance(like, Qty):
+        return Qty(u, s, like.unit)
+    return Money(u, s, like.cur) if isinstance(like, Money) else Dec(u, s)
+
+
+def _integral(v) -> bool:
+    """Целое значение: дробная часть нулевая. Статика плана гарантирует вид
+    Integer у операндов mod/pow, здесь — защита в глубину."""
+    return _is_num(v) and not isinstance(v, (Money, Qty)) and v.u % (10 ** v.s) == 0
+
+
+def _int(v) -> int:
+    return v.u // (10 ** v.s)
+
+
+# --- арифметика §58 ---------------------------------------------------------
+
+def add(a, b) -> Dec:
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        return _rat_pair(a, b, "add")
+    _same(a, b, "add")
+    x, y, s = _pair(a, b)
+    return _make(x + y, s, a)
+
+
+def sub(a, b) -> Dec:
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        return _rat_pair(a, b, "sub")
+    _same(a, b, "sub")
+    x, y, s = _pair(a, b)
+    return _make(x - y, s, a)
+
+
+def mul(a, b) -> Dec:
+    """Правило скаляра §49: безразмерное масштабирует размерное; масштаб
+    результата — сумма масштабов. Два размерных не перемножаются."""
+    if not (_is_num(a) and _is_num(b)):
+        raise Refused("§58: виды операндов не совпадают: mul")
+    if isinstance(a, (Money, Qty)) and isinstance(b, (Money, Qty)):
+        raise Refused("§58: произведение двух размерных величин не определено")
+    like = a if isinstance(a, (Money, Qty)) else b
+    return _make(a.u * b.u, a.s + b.s, like)
+
+
+def _gcd(a: int, b: int) -> int:
+    a, b = _b.abs(a), _b.abs(b)
+    while b:
+        a, b = b, a % b
+    return a
+
+
+def _exact(num: int, den: int):
+    """Точное десятичное частное num/den, если знаменатель 10-гладкий (§18),
+    иначе None. Масштаб — наименьший точный."""
+    g = _gcd(num, den) or 1
+    num, den = num // g, den // g
+    if den < 0:
+        num, den = -num, -den
+    twos = fives = 0
+    while den % 2 == 0:
+        den //= 2
+        twos += 1
+    while den % 5 == 0:
+        den //= 5
+        fives += 1
+    if den != 1:
+        return None
+    k = _b.max(twos, fives)
+    return num * 2 ** (k - twos) * 5 ** (k - fives), k
+
+
+def div(a, b) -> Dec:
+    """Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal,
+    Money/Money одной валюты. Integer/Integer даёт Rational — вне среза,
+    отвергается планом статически."""
+    if not (_is_num(a) and _is_num(b)):
+        raise Refused("§58: деление вне таблицы делимых")
+    if b.u == 0:
+        raise Refused("деление на ноль — evaluation error (§58)")
+    if isinstance(a, Money) and isinstance(b, Money):
+        if a.cur != b.cur:
+            raise Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+        like = None
+    elif isinstance(a, Money):
+        like = a
+    elif isinstance(b, Money):
+        raise Refused("§58: деление вне таблицы делимых")
+    else:
+        like = None
+    q = _exact(a.u * 10 ** b.s, b.u * 10 ** a.s)
+    if q is None:
+        if like is not None:
+            raise Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)")
+        raise Refused("§58: частное не 10-гладкое — Rational вне среза")
+    u, s = q
+    return Money(u, s, like.cur) if like is not None else Dec(u, s)
+
+
+def mod(a, b) -> Dec:
+    """Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов."""
+    if not (_integral(a) and _integral(b)):
+        raise Refused("§58: mod определён только для Integer")
+    y = _int(b)
+    if y == 0:
+        raise Refused("остаток от деления на ноль — evaluation error (§58)")
+    return Dec(_int(a) % _b.abs(y), 0)
+
+
+# --- Rational §35/§58 и арифметика по видам (DECISION-0252) ------------------
+
+def _rat_pair(a, b, op: str):
+    """add/sub/min/max над Rational: оба операнда Rational, иначе TYPE_ERROR §48."""
+    if not (isinstance(a, Rat) and isinstance(b, Rat)):
+        raise TermError("TYPE_ERROR")
+    if op == "add":
+        return Rat(a.n * b.d + b.n * a.d, a.d * b.d)
+    if op == "sub":
+        return Rat(a.n * b.d - b.n * a.d, a.d * b.d)
+    if op == "min":
+        return a if a.n * b.d <= b.n * a.d else b
+    return a if a.n * b.d >= b.n * a.d else b
+
+
+def kind_of(v) -> str:
+    """Вид значения динамического терма (DECISION-0252 п. 5): `r` Rational, `d` Decimal."""
+    return "r" if isinstance(v, Rat) else "d"
+
+
+_KINDS = ("i", "d", "m", "r", "q")
+
+
+def _resolve(v, k: str) -> str:
+    """Статический вид плана → вид значения; `n` — Decimal либо Rational по классу."""
+    if k == "n":
+        k = "r" if isinstance(v, Rat) else "d"
+    if k not in _KINDS or (k == "r") != isinstance(v, Rat) or (k == "m") != isinstance(v, Money) \
+            or (k == "q") != isinstance(v, Qty):
+        raise Refused("вид операнда расходится с планом: " + str(k))
+    return k
+
+
+def _exact_of(num: int, den: int, like):
+    """Точное десятичное num/den (§18) видом `like` (Money либо Dec) или None."""
+    q = _exact(num, den)
+    if q is None:
+        return None
+    if isinstance(like, Qty):
+        return Qty(q[0], q[1], like.unit)
+    return Money(q[0], q[1], like.cur) if isinstance(like, Money) else Dec(q[0], q[1])
+
+
+def _arith(op: str, a, b, lk: str, rk: str):
+    """Таблица §58 `values.binary` по видам операндов (DECISION-0252 п. 3–4).
+
+    Виды — из плана: `i` Integer, `d` Decimal, `m` Money, `r` Rational, `n` —
+    Decimal либо Rational по значению. Integer и Decimal рантайм по значению
+    не различает, поэтому пара решается видами, а не классами. Ошибка
+    значения — TermError с кодом оракула, в его порядке проверок."""
+    l, r = _resolve(a, lk), _resolve(b, rk)
+    pair = {l, r}
+    if op in ("add", "sub"):
+        if l == r == "m" and a.cur != b.cur:
+            raise TermError("CURRENCY_MISMATCH")
+        if l == r == "q" and a.unit != b.unit:
+            raise TermError("DIMENSION_MISMATCH")          # §49, T023
+        if l != r:
+            raise TermError("TYPE_ERROR")
+        if l == "r":
+            return _rat_pair(a, b, op)
+        return add(a, b) if op == "add" else sub(a, b)
+    if op == "mul":
+        if l == r == "i" or ("i" in pair and pair & {"m", "d", "q"}):
+            return mul(a, b)
+        if pair == {"i", "r"}:
+            q, k = (a, b) if l == "r" else (b, a)
+            return Rat(q.n * _int(k), q.d)
+        if "i" in pair:
+            raise TermError("TYPE_ERROR")
+        if l == r == "r":
+            return Rat(a.n * b.n, a.d * b.d)
+        if pair == {"m", "r"}:
+            # E-0085: доля масштабирует деньги точно; 10-гладкость — после сокращения.
+            m, q = (a, b) if l == "m" else (b, a)
+            out = _exact_of(m.u * q.n, 10 ** m.s * q.d, m)
+            if out is None:
+                raise TermError("INEXACT_DIVISION")
+            return out
+        if "r" in pair or pair in ({"m"}, {"q"}, {"m", "q"}):
+            raise TermError("TYPE_ERROR")
+        return mul(a, b)
+    if op == "div":
+        if l == r == "r":
+            if b.n == 0:
+                raise TermError("DIVISION_BY_ZERO")
+            return Rat(a.n * b.d, a.d * b.n)
+        if l == r == "i":
+            if _int(b) == 0:
+                raise TermError("DIVISION_BY_ZERO")
+            return Rat(_int(a), _int(b))
+        if "r" in pair:
+            raise TermError("TYPE_ERROR")
+        num, den = a.u * 10 ** b.s, b.u * 10 ** a.s
+        if l == r == "m":
+            # E-0083: частное сумм одной валюты безразмерно — Decimal либо Rational.
+            if a.cur != b.cur:
+                raise TermError("CURRENCY_MISMATCH")
+            if b.u == 0:
+                raise TermError("DIVISION_BY_ZERO")
+            out = _exact_of(num, den, None)
+            return out if out is not None else Rat(num, den)
+        if l == r == "q":
+            # E-0068: частное одной единицы безразмерно; разные единицы — TYPE_ERROR раньше нуля.
+            if a.unit != b.unit:
+                raise TermError("TYPE_ERROR")
+            if b.u == 0:
+                raise TermError("DIVISION_BY_ZERO")
+            out = _exact_of(num, den, None)
+            return out if out is not None else Rat(num, den)
+        if (l, r) not in (("d", "d"), ("m", "d"), ("q", "d")):
+            raise TermError("TYPE_ERROR")
+        if b.u == 0:
+            raise TermError("DIVISION_BY_ZERO")
+        out = _exact_of(num, den, a)
+        if out is not None:
+            return out
+        if l == "d":
+            return Rat(num, den)
+        raise TermError("INEXACT_DIVISION")
+    if op == "mod":
+        if l == r == "i":
+            y = _int(b)
+            if y == 0:
+                raise TermError("DIVISION_BY_ZERO")
+            return Dec(_int(a) % _b.abs(y), 0)
+        raise TermError("TYPE_ERROR")
+    raise Refused("операция вне среза рантайма: " + str(op))
+
+
+def arith(op: str, a, b, lk: str, rk: str):
+    for v in (a, b):
+        if isinstance(v, Dec):
+            _bounded_coefficient(v.u, v.s)
+    out = _arith(op, a, b, lk, rk)
+    if isinstance(out, Dec):
+        _bounded_coefficient(out.u, out.s)
+        if lk == rk == "i" and op in ("add", "sub", "mul", "mod") and not (-(1 << 63) <= out.u < (1 << 63)):
+            raise Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+    return out
+
+
+def min(a, b) -> Dec:                                        # noqa: A001
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        return _rat_pair(a, b, "min")
+    _same(a, b, "min")
+    x, y, _ = _pair(a, b)
+    return a if x <= y else b
+
+
+def max(a, b) -> Dec:                                        # noqa: A001
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        return _rat_pair(a, b, "max")
+    _same(a, b, "max")
+    x, y, _ = _pair(a, b)
+    return a if x >= y else b
+
+
+def abs(v) -> Dec:                                           # noqa: A001
+    if isinstance(v, Dec) and v.s == 0 and v.u == -(1 << 63):
+        raise Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary")
+    if isinstance(v, Rat):
+        return Rat(_b.abs(v.n), v.d)
+    if not _is_num(v):
+        raise Refused("§58: abs — не числовой вид")
+    return _make(v.u if v.u >= 0 else -v.u, v.s, v)
+
+
+POW_EXP_LIMIT = 4096
+POW_MIN, POW_MAX = -(2 ** 63), 2 ** 63 - 1
+
+
+def pow(base, exp) -> Dec:                                   # noqa: A001
+    """§58 (E-0075): только Integer pow Integer; порядок проверок — знак,
+    предел, вычисление, диапазон — часть контракта."""
+    if not (_integral(base) and _integral(exp)):
+        raise Refused("§58: pow определён только для Integer")
+    e = _int(exp)
+    if e < 0:
+        raise Refused("§58: pow — показатель отрицателен")
+    if e > POW_EXP_LIMIT:
+        raise Refused("RESOURCE_LIMIT: pow — показатель превышает 4096")
+    r = _int(base) ** e
+    if r < POW_MIN or r > POW_MAX:
+        raise Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+    return Dec(r, 0)
+
+
+def round(m, digits, mode: str) -> Dec:                      # noqa: A001
+    if mode != "HALF_UP":
+        raise Refused("§50: режим округления не реализован: " + mode)
+    if not _is_num(m):
+        raise Refused("§50: round — не числовой вид")
+    n = digits if isinstance(digits, int) else digits.u // 10 ** digits.s
+    if m.s <= n:
+        return _make(m.u * 10 ** (n - m.s), n, m)
+    drop = 10 ** (m.s - n)
+    neg = m.u < 0
+    a = -m.u if neg else m.u
+    q, r = divmod(a, drop)
+    up = q + 1 if r * 2 >= drop else q                       # HALF_UP — от нуля
+    return _make(-up if neg else up, n, m)
+
+
+# --- политика округления §50 (DECISION-0259) ---------------------------------
+
+ROUNDING_MODES = ("CEILING", "DOWN", "FLOOR", "HALF_DOWN", "HALF_EVEN", "HALF_UP", "UP")
+DIV_ROUND_MAX_PRECISION = 34
+
+
+def _round_int(num: int, den: int, mode: str) -> int:
+    """Порт `values._round_fraction` на целых: num/den (den > 0) к целому по
+    режиму §50; `2*tail` против знаменателя, ветви в порядке оракула."""
+    negative = num < 0
+    head, tail = divmod(-num if negative else num, den)
+    up = {
+        "HALF_UP": 2 * tail >= den,
+        "HALF_EVEN": 2 * tail > den or (2 * tail == den and head % 2 == 1),
+        "HALF_DOWN": 2 * tail > den,
+        "UP": tail > 0,
+        "DOWN": False,
+        "CEILING": tail > 0 and not negative,
+        "FLOOR": tail > 0 and negative,
+    }[mode]
+    if up:
+        head += 1
+    return -head if negative else head
+
+
+def _policy_scale(p, pk: str) -> int:
+    """Точность политики: Integer либо целый Decimal, вид — из плана. Дробная
+    точность — TYPE_ERROR; проверка на целом до любого приведения."""
+    if pk not in ("i", "d"):
+        raise Refused("вид точности расходится с планом: " + str(pk))
+    _resolve(p, pk)
+    if p.u % 10 ** p.s:
+        raise TermError("TYPE_ERROR")
+    return p.u // 10 ** p.s
+
+
+def _policy_mode(mode) -> str:
+    if not isinstance(mode, str) or mode not in ROUNDING_MODES:
+        raise TermError("TYPE_ERROR")
+    return mode
+
+
+def round_mode(v, p, mode, vk: str, pk: str):
+    """§50 `round` с проверкой политики (DECISION-0259 п. 4, 7): порядок
+    `values.round_value` — вид, точность (целое >= 0), режим. Integer — тождество
+    (E-0110); точность не короче дробной части — значение то же (E-0184)."""
+    k = _resolve(v, vk)
+    if k == "r":
+        raise TermError("TYPE_ERROR")
+    scale = _policy_scale(p, pk)
+    if scale < 0:
+        raise TermError("TYPE_ERROR")
+    mode = _policy_mode(mode)
+    if k == "i" or scale >= v.s:
+        return v
+    return _make(_round_int(v.u, 10 ** (v.s - scale), mode), scale, v)
+
+
+def div_round(a, b, p, mode, ak: str, bk: str, pk: str):
+    """§50/§58 `div_round` (E-0036, E-0170; DECISION-0259 п. 4, 7): пара →
+    валюта → ноль → точность 0..34 → режим. Частное точное, округление всегда;
+    Money/Money — доля Decimal без тега."""
+    l, r = _resolve(a, ak), _resolve(b, bk)
+    if (l, r) not in (("m", "d"), ("q", "d"), ("d", "d"), ("m", "m")):
+        raise TermError("TYPE_ERROR")
+    if l == r == "m" and a.cur != b.cur:
+        raise TermError("CURRENCY_MISMATCH")
+    if b.u == 0:
+        raise TermError("DIVISION_BY_ZERO")
+    scale = _policy_scale(p, pk)
+    if not 0 <= scale <= DIV_ROUND_MAX_PRECISION:
+        raise TermError("TYPE_ERROR")
+    mode = _policy_mode(mode)
+    num, den = a.u * 10 ** (b.s + scale), b.u * 10 ** a.s
+    if den < 0:
+        num, den = -num, -den
+    q = _round_int(num, den, mode)
+    return Dec(q, scale) if r == "m" else _make(q, scale, a)
+
+
+# --- сравнение и равенство ---------------------------------------------------
+
+def cmp(a, op: str, b) -> bool:                              # noqa: A001
+    if isinstance(a, bool) or isinstance(b, bool):
+        # §57 (DECISION-0266): Boolean сравнимо только на равенство и только с Boolean.
+        same_bool = isinstance(a, bool) and isinstance(b, bool) and a == b
+        if op == "eq":
+            return same_bool
+        if op == "ne":
+            return not same_bool
+        raise Refused("§57: вид Boolean не упорядочен")
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        # §57/§48 (DECISION-0252 п. 6): Rational сравнивается только с Rational;
+        # иной вид — TYPE_ERROR оракула, а не false.
+        if not (isinstance(a, Rat) and isinstance(b, Rat)):
+            raise TermError("TYPE_ERROR")
+        x, y = a.n * b.d, b.n * a.d
+        table = {"lt": x < y, "le": x <= y, "gt": x > y, "ge": x >= y,
+                 "eq": x == y, "ne": x != y}
+        if op not in table:
+            raise Refused("сравнение вне среза рантайма: " + op)
+        return table[op]
+    if isinstance(a, Qty) or isinstance(b, Qty):
+        # §49/§57 (DECISION-0256 п. 5): величина — только с величиной той же единицы.
+        _same(a, b, "cmp")
+        x, y, _ = _pair(a, b)
+        table = {"lt": x < y, "le": x <= y, "gt": x > y, "ge": x >= y,
+                 "eq": x == y, "ne": x != y}
+        if op not in table:
+            raise Refused("сравнение вне среза рантайма: " + op)
+        return table[op]
+    if isinstance(a, Sym) or isinstance(b, Sym):
+        if op == "eq":
+            return isinstance(a, Sym) and isinstance(b, Sym) and a.id == b.id
+        if op == "ne":
+            return not (isinstance(a, Sym) and isinstance(b, Sym) and a.id == b.id)
+        raise Refused("§57: вид enum не упорядочен")
+    if isinstance(a, Instant) or isinstance(b, Instant):
+        if isinstance(a, Instant) and isinstance(b, Instant):
+            x, y = _moment_pair(op, a, b)
+            table = {"lt": x < y, "le": x <= y, "gt": x > y, "ge": x >= y, "eq": x == y, "ne": x != y}
+            if op not in table:
+                raise Refused("сравнение вне среза рантайма: " + op)
+            return table[op]
+        # §57/§2.15: Date и Instant не сравниваются (DATE_INSTANT_MISMATCH оракула).
+        raise Refused("§57: Instant сравнивается только с Instant")
+    if isinstance(a, Date) or isinstance(b, Date):
+        if isinstance(a, Date) and isinstance(b, Date):
+            table = {"lt": a.v < b.v, "le": a.v <= b.v, "gt": a.v > b.v, "ge": a.v >= b.v,
+                     "eq": a.v == b.v, "ne": a.v != b.v}
+            if op not in table:
+                raise Refused("сравнение вне среза рантайма: " + op)
+            return table[op]
+        if op == "eq":
+            return False
+        if op == "ne":
+            return True
+        raise Refused("§57: Date сравнивается только с Date")
+    if isinstance(a, str) or isinstance(b, str):
+        if op == "eq":
+            return a == b
+        if op == "ne":
+            return a != b
+        raise Refused("порядок на Text вне среза рантайма: " + op)
+    if isinstance(a, Money) != isinstance(b, Money):
+        raise Refused("§49: сравнение денег с безразмерным")
+    if isinstance(a, Money) and a.cur != b.cur:
+        raise Refused("§49: разные валюты")
+    x, y, _ = _pair(a, b)
+    table = {"lt": x < y, "le": x <= y, "gt": x > y, "ge": x >= y,
+             "eq": x == y, "ne": x != y}
+    if op not in table:
+        raise Refused("сравнение вне среза рантайма: " + op)
+    return table[op]
+
+
+def eq(a, b) -> bool:
+    if isinstance(a, bool) or isinstance(b, bool):
+        # DECISION-0266: Boolean равен только Boolean того же значения; bool —
+        # подкласс int в Python, поэтому ветвь стоит первой.
+        return isinstance(a, bool) and isinstance(b, bool) and a == b
+    if isinstance(a, Rat) or isinstance(b, Rat):
+        return isinstance(a, Rat) and isinstance(b, Rat) and a.n == b.n and a.d == b.d
+    if isinstance(a, Qty) or isinstance(b, Qty):
+        if not (isinstance(a, Qty) and isinstance(b, Qty)) or a.unit != b.unit:
+            return False
+        x, y, _ = _pair(a, b)
+        return x == y
+    if isinstance(a, Sym) or isinstance(b, Sym):
+        return isinstance(a, Sym) and isinstance(b, Sym) and a.id == b.id
+    if isinstance(a, Date) or isinstance(b, Date):
+        return isinstance(a, Date) and isinstance(b, Date) and a.v == b.v
+    if isinstance(a, Instant) or isinstance(b, Instant):
+        if not (isinstance(a, Instant) and isinstance(b, Instant)):
+            return False
+        x, y = _moment_pair("eq", a, b)
+        return x == y
+    if isinstance(a, str) or isinstance(b, str):
+        return a == b
+    if isinstance(a, Money) != isinstance(b, Money):
+        return False
+    if isinstance(a, Money) and a.cur != b.cur:
+        return False
+    x, y, _ = _pair(a, b)
+    return x == y
+
+
+def _norm(d: Dec) -> str:
+    u, s = d.u, d.s
+    if u == 0:
+        return "0e-0"
+    while s > 0 and u % 10 == 0:
+        u //= 10
+        s -= 1
+    return f"{u}e-{s}"
+
+
+def _esc(text: str) -> str:
+    """Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    ["a","b|e:c"] склеивались в один ключ, и второй факт терялся."""
+    return text.replace("\\", "\\\\").replace("|", "\\|")
+
+
+def key(row) -> str:
+    out = []
+    for v in row:
+        if isinstance(v, str):
+            out.append("e:" + _esc(v))
+        elif isinstance(v, bool):
+            out.append("b:" + ("true" if v else "false"))
+        elif isinstance(v, Date):
+            out.append("t:" + v.v)
+        elif isinstance(v, Instant):
+            out.append("i:" + _esc(v.v))
+        elif isinstance(v, Sym):
+            out.append("c:" + _esc(v.id))
+        elif isinstance(v, Rat):
+            out.append(f"r:{v.n}/{v.d}")
+        elif isinstance(v, Qty):
+            out.append("q:" + _esc(v.unit) + ":" + _norm(v))
+        elif isinstance(v, Money):
+            out.append("m:" + v.cur + ":" + _norm(v))
+        else:
+            out.append("d:" + _norm(v))
+    return "|".join(out)
+
+
+class _Context:
+    """Контекст одного вычисления (DECISION-0423 §2.3): правовое время дела,
+    политика срока §86, снимок календаря §85 и загруженный календарь. Живёт в
+    `contextvars`: `evaluate` открывает новый контекст на каждый вызов, и
+    параллельные вызовы из потоков его не делят."""
+    __slots__ = ("legal_time", "policy", "snapshot", "cal")
+
+    def __init__(self):
+        self.legal_time = ""
+        self.policy = None      # DeadlinePolicy §86 дела либо None
+        self.snapshot = None    # запись снимка плана (`calendars`) либо None
+        self.cal = None         # загруженный календарь
+
+
+_CONTEXT = _cv.ContextVar("law_codegen_context")
+
+
+def begin_context() -> None:
+    """Новый пустой контекст вычисления в текущем `contextvars.Context`."""
+    _CONTEXT.set(_Context())
+
+
+def _ctx() -> _Context:
+    try:
+        return _CONTEXT.get()
+    except LookupError:
+        c = _Context()
+        _CONTEXT.set(c)
+        return c
+
+
+def set_legal_time(t: str) -> None:
+    _ctx().legal_time = t
+
+
+def legal_time() -> str:
+    t = _ctx().legal_time
+    if not t:
+        raise Refused("legalTime не подан делом")
+    return t
+
+
+# --- календарь §84–§86 (DECISION-0245) ---------------------------------------
+# Порт `lawref.values` и `lawref.calendar` дословно по порядку проверок: код
+# ошибки — часть ответа (issue модели), а не текст.
+
+import datetime as _dt
+
+
+class TermError(Exception):
+    """Ошибка вычисления терма §58 с кодом: модель превращает её в issue
+    правила (`support.term_error` оракула)."""
+
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.code = code
+
+
+def set_calendar(policy, snapshot) -> None:
+    c = _ctx()
+    c.policy, c.snapshot, c.cal = policy, snapshot, None
+
+
+_WEEKDAYS = ("monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday")
+
+
+def _calendar():
+    """`TermEnv.calendar`: ленивая загрузка; ошибка загрузки — код плана."""
+    c = _ctx()
+    if c.cal is None:
+        snap = c.snapshot
+        if snap is None or snap.get("error") == "MISSING_CALENDAR":
+            raise TermError("MISSING_CALENDAR")
+        if "error" in snap:
+            raise TermError(snap["error"])
+        c.cal = (_dt.date.fromisoformat(snap["start"]), _dt.date.fromisoformat(snap["endExclusive"]),
+                 snap["weekly"], {_dt.date.fromisoformat(k): v for k, v in snap["overrides"].items()})
+    return c.cal
+
+
+def _coverage(cal, day) -> None:
+    if not (cal[0] <= day < cal[1]):
+        raise TermError("CALENDAR_OUT_OF_RANGE")
+
+
+def _working(cal, day) -> bool:
+    _coverage(cal, day)
+    if day in cal[3]:
+        return cal[3][day]
+    return cal[2][day.weekday()]
+
+
+def _previous_working(cal, day):
+    _coverage(cal, day)
+    current = day - _dt.timedelta(days=1)
+    while True:
+        _coverage(cal, current)
+        if _working(cal, current):
+            return current
+        current -= _dt.timedelta(days=1)
+
+
+def _next_working(cal, day):
+    while not _working(cal, day):
+        day += _dt.timedelta(days=1)
+        _coverage(cal, day)
+    return day
+
+
+def _last_day(year: int, month: int) -> int:
+    if month == 12:
+        return 31
+    return (_dt.date(year, month + 1, 1) - _dt.timedelta(days=1)).day
+
+
+def _add_months(day, months: int, month_end: str):
+    total = day.month - 1 + months
+    year, month = day.year + total // 12, total % 12 + 1
+    last = _last_day(year, month)
+    if day.day <= last:
+        return _dt.date(year, month, day.day)
+    if month_end == "last_day_of_month":
+        return _dt.date(year, month, last)
+    raise TermError("DEADLINE_POLICY_INVALID")
+
+
+def _needs_calendar(unit: str, policy) -> bool:
+    if unit not in ("calendar_month", "calendar_year", "calendar_week"):
+        return True
+    policy = policy or {}
+    return policy.get("roll") != "no_roll" or policy.get("include_end") is not True
+
+
+def _deadline(cal, after, count: int, policy, after_time, unit: str, calendar_day_step: bool = False):
+    """Порт `calendar.compute_deadline` без приостановлений (терм их не несёт)."""
+    if policy is None:
+        raise TermError("MISSING_POLICY")
+    if set(policy) - {"start_count", "include_end", "roll", "cutoff", "month_end"}:
+        raise TermError("DEADLINE_POLICY_INVALID")
+    start_count, roll = policy.get("start_count"), policy.get("roll")
+    include_end, cutoff = policy.get("include_end"), policy.get("cutoff")
+    if start_count not in ("same_day", "next_day") \
+            or roll not in ("no_roll", "next_working_day", "previous_working_day") \
+            or not isinstance(include_end, bool) or not (cutoff is None or isinstance(cutoff, str)):
+        raise TermError("DEADLINE_POLICY_INVALID")
+    if count < 0:
+        raise TermError("DEADLINE_POLICY_INVALID")
+    month_end = policy.get("month_end")
+    if unit in ("calendar_month", "calendar_year"):
+        if month_end not in ("last_day_of_month", "reject_nonexistent"):
+            raise TermError("DEADLINE_POLICY_INVALID")
+    elif month_end is not None and month_end not in ("last_day_of_month", "reject_nonexistent"):
+        raise TermError("DEADLINE_POLICY_INVALID")
+    start = after
+    wants = False if calendar_day_step else _needs_calendar(unit, policy)
+    if wants:
+        _coverage(cal, start)
+    if cutoff is not None and after_time is not None and after_time > cutoff:
+        start += _dt.timedelta(days=1)
+        if wants:
+            _coverage(cal, start)
+    if start_count == "next_day":
+        start += _dt.timedelta(days=1)
+        if wants:
+            _coverage(cal, start)
+    if unit in ("calendar_month", "calendar_year"):
+        months = count * (12 if unit == "calendar_year" else 1)
+        due = _add_months(start, months, month_end) if count > 0 else start
+        if count > 0 and not include_end:
+            _coverage(cal, due)
+            due = _previous_working(cal, due)
+    elif calendar_day_step or unit == "calendar_week":
+        multiplier = 1 if calendar_day_step else 7
+        due = start + _dt.timedelta(days=multiplier * count) if count > 0 else start
+        if count > 0 and not include_end:
+            _coverage(cal, due)
+            due = _previous_working(cal, due)
+    elif count > 0:
+        due, counted = start, 0
+        while True:
+            _coverage(cal, due)
+            if (_working(cal, due) if unit == "business_day" else True):
+                counted += 1
+                if counted == count:
+                    break
+            due += _dt.timedelta(days=1)
+        if not include_end:
+            due = _previous_working(cal, due)
+    else:
+        due = start
+    skip_roll = (calendar_day_step or unit in ("calendar_month", "calendar_year", "calendar_week")) \
+        and roll == "no_roll"
+    if not skip_roll and not _working(cal, due) and roll != "no_roll":
+        due = _next_working(cal, due) if roll == "next_working_day" else _previous_working(cal, due)
+    return due
+
+
+def _month_parts(d) -> tuple:
+    """§84.2 (E-0084, DECISION-0267): год, месяц и последнее число месяца
+    даты; не Date и не ISO-дата — TYPE_ERROR (`values.month_bound_value`)."""
+    if not isinstance(d, Date):
+        raise TermError("TYPE_ERROR")
+    try:
+        day = _dt.date.fromisoformat(d.v)
+    except ValueError:
+        raise TermError("TYPE_ERROR") from None
+    if len(d.v) != 10:
+        raise TermError("TYPE_ERROR")
+    return day.year, day.month, _last_day(day.year, day.month)
+
+
+def month_start(d) -> Date:
+    """§84.2: первое число месяца; политика §86 и снимок §85 не читаются."""
+    y, m, _ = _month_parts(d)
+    return Date(f"{y:04d}-{m:02d}-01")
+
+
+def month_end(d) -> Date:
+    """§84.2: последнее число месяца."""
+    y, m, last = _month_parts(d)
+    return Date(f"{y:04d}-{m:02d}-{last:02d}")
+
+
+def days_between(a: Date, b: Date) -> Dec:
+    """§84.4 (E-0015): календарные дни от `a` до `b`, со знаком."""
+    return Dec((_dt.date.fromisoformat(b.v) - _dt.date.fromisoformat(a.v)).days, 0)
+
+
+def _duration_between(a, b, unit: int, where: str) -> Dec:
+    """§84.1 (E-0028/E-0058): полных единиц между мгновениями, знак сохранён, дробь к нулю."""
+    if not (isinstance(a, Instant) and isinstance(b, Instant)):
+        raise TermError("TYPE_ERROR")
+    x, y = _moment(a), _moment(b)
+    seconds = y[0] - x[0]
+    if seconds > 0 and y[1] < x[1]:
+        seconds -= 1
+    elif seconds < 0 and y[1] > x[1]:
+        seconds += 1
+    return Dec(seconds // unit if seconds >= 0 else -((-seconds) // unit), 0)
+
+
+def hours_between(a, b) -> Dec:
+    return _duration_between(a, b, 3600, "hours_between")
+
+
+def minutes_between(a, b) -> Dec:
+    return _duration_between(a, b, 60, "minutes_between")
+
+
+_DURATION_SECONDS = {"second": 1, "minute": 60, "hour": 3600, "day": 86400}
+
+
+def add_duration(after, count: int, unit: str) -> Instant:
+    """§84.1 (E-0185): мгновение через целую Quantity секунд/минут/часов/суток; канон UTC без дробных секунд."""
+    if not isinstance(after, Instant) or unit not in _DURATION_SECONDS:
+        raise TermError("TYPE_ERROR")
+    seconds, _ = _moment(after)
+    try:
+        result = _dt.datetime(1970, 1, 1) + _dt.timedelta(seconds=seconds + int(count) * _DURATION_SECONDS[unit])
+    except (OverflowError, ValueError) as exc:
+        raise TermError("RESOURCE_LIMIT") from exc
+    return Instant(f"{result.year:04d}-{result.month:02d}-{result.day:02d}T{result.hour:02d}:{result.minute:02d}:{result.second:02d}Z")
+
+
+def add_calendar_period(after: Date, count: int, unit: str) -> Date:
+    """§84.2 (E-0029): `TermEnv.calendar_period` — снимок не читается."""
+    policy = _ctx().policy or {}
+    if policy.get("roll") not in (None, "no_roll") or policy.get("cutoff") is not None \
+            or policy.get("include_end") is not True:
+        raise TermError("MISSING_POLICY")
+    due = _deadline(None, _dt.date.fromisoformat(after.v), count, policy, None, unit,
+                    calendar_day_step=(unit == "calendar_day"))
+    return Date(due.isoformat())
+
+
+_COUNTER_UNITS = {
+    "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"),
+}
+
+
+def counter(v, fn: str) -> tuple:
+    """§86.1 (DECISION-0256 п. 6): счётчик-связыватель — Quantity с единицей,
+    допустимой функции, целый; иначе TYPE_ERROR (`values.add_*_value`). Знак не
+    проверяется: отрицательный счётчик отвергает сама операция политикой §86."""
+    if not isinstance(v, Qty) or v.unit not in _COUNTER_UNITS[fn] or v.u % (10 ** v.s) != 0:
+        raise TermError("TYPE_ERROR")
+    return v.u // (10 ** v.s), v.unit
+
+
+def add_legal_term(after: Date, count: int, unit: str) -> Date:
+    """§86.1: ветвь по единице на деле — рабочий счёт либо календарный шаг."""
+    if unit in ("business_day", "calendar_day"):
+        return add_business_days(after, count, unit)
+    return add_calendar_period(after, count, unit)
+
+
+def add_business_days(after: Date, count: int, unit: str, after_time=None) -> Date:
+    """§86: `TermEnv.deadline` — политика, затем снимок, если срок его спрашивает."""
+    policy = _ctx().policy
+    if policy is not None and policy.get("cutoff") is not None and after_time is None:
+        raise TermError("MISSING_POLICY")
+    cal = _calendar() if _needs_calendar(unit, policy) else None
+    due = _deadline(cal, _dt.date.fromisoformat(after.v), count, policy, after_time, unit)
+    return Date(due.isoformat())
+
+
+# ---------------------------------------------------------------------------
+# §47.3 Канал суждения (DECISION-0274): порт `whynot.judgment_blockers`,
+# `defeater_judgment_blockers`, `power_judgment_blockers` и
+# `position_judgment_blockers` над ГОТОВЫМ состоянием модели. Один код для
+# раннера и API: модель и переводы термов приходят параметрами (`hooks`:
+# `val` — литерал-терм §53 → значение, `cell` — ячейка таблицы → литерал-терм).
+# Запрос называет судью только там, где его ответ может изменить исход:
+# живость правила по конъюнктам (E-0101), по поражению вывода (E-0103), по
+# способности дефитера снять вывод (E-0100), по иммунитету (E-0120); порядок
+# запросов — канонические байты объекта `request` (E-0111).
+JUDGMENT_ENUM_CAP = 8
+_J_TESTABLE = ("established", "supported", "monotone", "refuted")
+_J_MIRROR = {"TRUE_ONLY": "FALSE_ONLY", "FALSE_ONLY": "TRUE_ONLY", "BOTH": "BOTH", "NEITHER": "NEITHER"}
+_J_CONJUNCT = {"TRUE_ONLY": "SATISFIED", "FALSE_ONLY": "NOT_SATISFIED", "BOTH": "CONFLICTED", "NEITHER": "UNDETERMINED"}
+_J_COMPUTED = ("binary", "call", "if", "let", "match", "aggregate")
+
+
+def jcanon(v) -> str:
+    """Канонические байты §208 объекта запроса: ключи по порядку, целое из JSON — цифрами."""
+    import json as _json
+    if isinstance(v, dict) and set(v) == {"int"}:
+        return str(v["int"])
+    if isinstance(v, dict):
+        return "{" + ",".join(_json.dumps(k, ensure_ascii=False) + ":" + jcanon(v[k]) for k in sorted(v)) + "}"
+    if isinstance(v, list):
+        return "[" + ",".join(jcanon(x) for x in v) + "]"
+    return _json.dumps(v, ensure_ascii=False)
+
+
+def request_key(lit: dict) -> str:
+    return jcanon({"relation": lit["predicate"], "polarity": lit.get("polarity", "positive"), "args": lit.get("args") or []})
+
+
+def order_requests(lits: list) -> list:
+    found: dict = {}
+    for lit in lits:
+        found.setdefault(request_key(lit), lit)
+    return [found[k] for k in sorted(found)]
+
+
+def _jtruth(M, hooks, lit: dict) -> str:
+    st = M.status(lit["predicate"], [hooks["val"](a) for a in lit.get("args") or []])
+    return _J_MIRROR[st] if lit.get("polarity", "positive") == "negative" else st
+
+
+def _jvars(t, out: set) -> None:
+    if isinstance(t, list):
+        for x in t:
+            _jvars(x, out)
+    elif isinstance(t, dict):
+        if t.get("kind") == "var":
+            out.add(str(t.get("var")))
+        else:
+            for v in t.values():
+                _jvars(v, out)
+
+
+def _jkind(name: str) -> str:
+    return {"urn:law:std#Integer": "i", "urn:law:std#Natural": "i", "urn:law:std#Decimal": "d", "urn:law:std#Money": "m",
+            "urn:law:std#Rational": "r", "urn:law:std#Quantity": "q"}.get(name, "x")
+
+
+def _jterm(M, hooks, t: dict, subst: dict):
+    """Гард §57–§58 под подстановкой: переменные, литералы, константы §54 и
+    арифметика §58; иное — исключение, у оракула это UNDETERMINED (E-0101)."""
+    k = t.get("kind")
+    if k == "var":
+        if t["var"] not in subst:
+            raise Refused("несвязанная переменная гарда")
+        return _jterm(M, hooks, subst[t["var"]], subst)
+    consts = getattr(M, "BACKCHAIN_CONSTS", None) or {}
+    if k == "const_ref" and t.get("id") in consts:
+        return _jterm(M, hooks, consts[t["id"]], subst)
+    if k == "value":
+        return hooks["val"](t), _jkind(str((t.get("type") or {}).get("name")))
+    if k in ("entity_ref", "const_ref"):
+        return hooks["val"](t), "x"
+    if k == "binary" and t.get("op") in ("add", "sub", "mul", "div", "mod"):
+        lv, lk = _jterm(M, hooks, t["left"], subst)
+        rv, rk = _jterm(M, hooks, t["right"], subst)
+        if lk == "x" or rk == "x":
+            raise Refused("арифметика над нечисловым операндом")
+        v = arith(t["op"], lv, rv, lk, rk)
+        kind = "r" if isinstance(v, Rat) else "m" if isinstance(v, Money) else "q" if isinstance(v, Qty) \
+            else "i" if lk == "i" and rk == "i" else "d"
+        return v, kind
+    raise Refused(f"терм гарда вне обхода суждения: {k}")
+
+
+def _jconjunct(M, hooks, status: str, lit: dict, subst: dict):
+    """Порт `whynot._conjunct_report`: None — конъюнкт с несвязанной переменной;
+    иначе (trigger, ground) — ground None у гарда, квантора и вычисляемого аргумента."""
+    if status == "guard":
+        names: set = set()
+        _jvars(lit, names)
+        if any(n not in subst for n in names):
+            return None
+        try:
+            lv, _ = _jterm(M, hooks, lit["left"], subst)
+            rv, _ = _jterm(M, hooks, lit["right"], subst)
+            ok = cmp(lv, lit["op"], rv)
+        except Exception:  # noqa: BLE001 — терм-ошибка §58 не убивает правило
+            return ("UNDETERMINED", None)
+        return ("SATISFIED" if ok else "NOT_SATISFIED", None)
+    if (lit or {}).get("kind") != "literal":
+        return ("UNDETERMINED", None)
+    args = lit.get("args") or []
+    names = set()
+    _jvars(args, names)
+    if any(n not in subst for n in names):
+        return None
+    if any((a or {}).get("kind") in _J_COMPUTED for a in args):
+        return ("UNDETERMINED", None)
+    shown = dict(lit, args=[subst[a["var"]] if a.get("kind") == "var" else a for a in args])
+    if any((a or {}).get("kind") == "wildcard" for a in args):
+        # §98 (E-0165): свидетель существования, значение не связывается.
+        if lit.get("polarity", "positive") != "positive" or status not in ("established", "supported", "monotone"):
+            return ("UNDETERMINED", shown)
+        want = [None if a.get("kind") == "wildcard" else hooks["val"](a) for a in shown["args"]]
+        rows = M.TABLES.get(lit["predicate"], [])
+        witness = any(len(r) == len(want) and all(w is None or key([v]) == key([w]) for v, w in zip(r, want))
+                      and (M.status(lit["predicate"], r) == "TRUE_ONLY" if status == "established"
+                           else M.status(lit["predicate"], r) in ("TRUE_ONLY", "BOTH"))
+                      for r in rows)
+        return ("SATISFIED" if witness else "UNDETERMINED", shown)
+    pair = _jtruth(M, hooks, shown)
+    if status == "not_known":
+        return ("SATISFIED" if pair == "NEITHER" else "NOT_SATISFIED", shown)
+    if status in ("supported", "monotone"):
+        return ("SATISFIED" if pair in ("TRUE_ONLY", "BOTH") else "UNDETERMINED", shown)
+    if status in ("refuted", "unknown"):
+        want_pair = "FALSE_ONLY" if status == "refuted" else "NEITHER"
+        return ("SATISFIED" if pair == want_pair else "NOT_SATISFIED", shown)
+    return (_J_CONJUNCT.get(pair, "UNDETERMINED"), shown)
+
+
+def _junify(head: dict, target: dict):
+    """Порт `unify_head`: подстановка головы под ground-цель; переменная дважды — одинаково."""
+    if (head or {}).get("kind") != "literal" or (target or {}).get("kind") != "literal":
+        return None
+    if head.get("predicate") != target.get("predicate"):
+        return None
+    if head.get("polarity", "positive") != target.get("polarity", "positive"):
+        return None
+    h, g = head.get("args") or [], target.get("args") or []
+    if len(h) != len(g):
+        return None
+    subst: dict = {}
+    for x, y in zip(h, g):
+        if x.get("kind") == "var":
+            if x["var"] in subst and jcanon(subst[x["var"]]) != jcanon(y):
+                return None
+            subst[x["var"]] = y
+        elif jcanon(x) != jcanon(y):
+            return None
+    return subst
+
+
+def _jenumerate(M, hooks, lit: dict, subst: dict, unbound: list) -> list:
+    """DECISION-0036 (б): перечисление судейского конъюнкта по активному домену —
+    аргументы всех атомов таблиц, порядок §208, кап ДО фильтра по NEITHER."""
+    args = lit.get("args") or []
+    if any((a or {}).get("kind") == "wildcard" for a in args):
+        return []
+    domain: dict = {}
+    for pred, rows in M.TABLES.items():
+        for row in rows:
+            for i, v in enumerate(row):
+                t = hooks["cell"](pred, i, v)
+                domain[jcanon(t)] = t
+    terms = [domain[k] for k in sorted(domain)]
+    if not terms:
+        return []
+    names = sorted(unbound)
+    out: list = []
+    total = len(terms) ** len(names)
+    for idx in range(total if total < JUDGMENT_ENUM_CAP else JUDGMENT_ENUM_CAP):   # `min` здесь — функция §58 рантайма
+        # itertools.product: первая переменная меняется медленнее всех.
+        full = dict(subst)
+        rest = idx
+        for name in reversed(names):
+            full[name] = terms[rest % len(terms)]
+            rest //= len(terms)
+        ground = dict(lit, args=[full[a["var"]] if a.get("kind") == "var" else a for a in args])
+        if _jtruth(M, hooks, ground) == "NEITHER":
+            out.append(ground)
+    return out
+
+
+def _jprio(M) -> set:
+    return getattr(M, "PRIO_ACTIVE", None) if getattr(M, "PRIO_ACTIVE", None) is not None else getattr(M, "PRIO", set())
+
+
+def _jrow_key(hooks, lit: dict) -> str:
+    return key([hooks["val"](a) for a in lit.get("args") or []])
+
+
+def _jconclusion_defeated(M, hooks, rule: dict, target: dict) -> bool:
+    """E-0103: поражён ли был бы вывод поражаемого правила при любом ответе судьи."""
+    if rule.get("strength") != "defeasible":
+        return False
+    prio, tkey = _jprio(M), _jrow_key(hooks, target)
+    pos = target.get("polarity", "positive") != "negative"
+    for a in getattr(M, "APPLIED", []):
+        if not a["defeater"] or a["urn"] != target["predicate"] or a["key"] != tkey or a["positive"] != pos:
+            continue
+        if (rule["name"], a["rule"]) not in prio:
+            return True
+    return False
+
+
+def _jdefeater_can_remove(M, hooks, rule: dict, target: dict) -> bool:
+    """E-0100: способен ли живой дефитер снять СТОЯЩИЙ вывод — строгая опора не
+    поражается; каждое уцелевшее поражаемое применение обязано уступать ему."""
+    row = [hooks["val"](a) for a in target.get("args") or []]
+    bits = M.support_bits(target["predicate"], row) if hasattr(M, "support_bits") else 0
+    pos = target.get("polarity", "positive") != "negative"
+    if bits & (1 if pos else 2):
+        return False
+    tkey, prio = key(row), _jprio(M)
+    apps = [a for a in getattr(M, "APPLIED", [])
+            if not a["defeater"] and not a["defeated"] and a["urn"] == target["predicate"] and a["key"] == tkey and a["positive"] == pos]
+    if not apps:
+        return False
+    return all((a["rule"], rule["name"]) not in prio for a in apps)
+
+
+def collect_judgments(M, hooks, goal: dict, root_defeaters: bool) -> list:
+    """Порт `whynot._collect_judgments`: общий обход §185 от цели без опоры
+    (root_defeaters=False) и от стоящей цели через дефитеры её головы (True)."""
+    J = getattr(M, "JUDGMENTS", {}) or {}
+    index: dict = {}
+    for r in getattr(M, "BACKCHAIN", []) or []:
+        index.setdefault(r["head"]["predicate"], []).append(r)
+    found: dict = {}
+    visited: set = set()
+    now = legal_time()
+
+    def dead(reports) -> bool:
+        for st, _lit, rep in reports:
+            if rep is None or rep[0] not in ("NOT_SATISFIED", "CONFLICTED"):
+                continue
+            # DECISION-0036 (а): refuted-тест над самим отношением суждения при паре NEITHER решает судья.
+            if st == "refuted" and rep[1] is not None and rep[1]["predicate"] in J and _jtruth(M, hooks, rep[1]) == "NEITHER":
+                continue
+            return True
+        return False
+
+    def walk(target: dict, defeaters_only: bool) -> None:
+        vkey = jcanon({"p": target["predicate"], "a": target.get("args") or [], "n": target.get("polarity", "positive")})
+        if vkey in visited:
+            return
+        visited.add(vkey)
+        for r in index.get(target["predicate"], ()):
+            if defeaters_only and r.get("strength") != "defeater":
+                continue
+            subst = _junify(r["head"], target)
+            if subst is None:
+                continue
+            w = r.get("window")
+            if w and ((w.get("start") and now < w["start"]) or (w.get("end") and now >= w["end"])):
+                continue
+            reports = [(st, lit, _jconjunct(M, hooks, st, lit, subst)) for st, lit in r["body"]]
+            if dead(reports):
+                continue
+            if _jconclusion_defeated(M, hooks, r, target):
+                continue
+            if defeaters_only and not _jdefeater_can_remove(M, hooks, r, target):
+                continue
+            for st, lit, rep in reports:
+                if rep is None:
+                    if st in _J_TESTABLE and (lit or {}).get("kind") == "literal" and lit.get("predicate") in J:
+                        names: set = set()
+                        _jvars(lit.get("args") or [], names)
+                        for g in _jenumerate(M, hooks, lit, subst, [n for n in names if n not in subst]):
+                            found.setdefault(request_key(g), g)
+                    continue
+                trigger, ground = rep
+                if ground is None or ground.get("kind") != "literal" \
+                        or any((a or {}).get("kind") == "wildcard" for a in ground.get("args") or []):
+                    continue
+                if trigger == "UNDETERMINED":
+                    if ground["predicate"] in J:
+                        found.setdefault(request_key(ground), ground)
+                    else:
+                        walk(ground, False)
+                elif st == "refuted" and trigger == "NOT_SATISFIED" and ground["predicate"] in J \
+                        and _jtruth(M, hooks, ground) == "NEITHER":
+                    found.setdefault(request_key(ground), ground)
+
+    walk(goal, root_defeaters)
+    return list(found.values())
+
+
+def _nlit_literal(hooks, n) -> dict:
+    pred, positive, row = n[0], n[1], n[2]
+    return {"kind": "literal", "polarity": "positive" if positive else "negative", "predicate": pred,
+            "args": [hooks["cell"](pred, i, v) for i, v in enumerate(row)]}
+
+
+def _nlit_status(M, n) -> str:
+    st = M.status(n[0], n[2])
+    return st if n[1] else _J_MIRROR[st]
+
+
+def power_judgments(M, hooks, goal: dict) -> list:
+    """E-0100, носитель `valid_when` §127: судьи действительности осуществлённого
+    полномочия, чей эффект есть цель; E-0120 — не при эффекте, запертом иммунитетом."""
+    J = getattr(M, "JUDGMENTS", {}) or {}
+    if goal.get("polarity", "positive") != "positive" or not hasattr(M, "POSITIONS"):
+        return []
+    gkey = (goal["predicate"], _jrow_key(hooks, goal))
+    if gkey in (getattr(M, "BLOCKED_IMMUNITY", None) or set()):
+        return []
+    out: list = []
+    for p in M.POSITIONS:
+        if p["modality"] != "power" or p["status"] != "ACTIVE":
+            continue
+        eff = p["spec"]["effect"]
+        if eff is None or not eff[1] or eff[0] != goal["predicate"] or key(eff[2]) != gkey[1]:
+            continue
+        ex = p["spec"]["exercise"]
+        if ex is None or _nlit_status(M, ex) not in ("TRUE_ONLY", "BOTH"):
+            continue
+        vw = p["spec"]["validWhen"]
+        if vw is None or vw[0] not in J:
+            continue
+        if _nlit_status(M, vw) == "NEITHER":
+            out.append(_nlit_literal(hooks, vw))
+    return order_requests(out)
+
+
+def position_judgments(M, hooks) -> list:
+    """E-0100, носитель `condition` цели §123/§124: судьи статуса позиции обязанности."""
+    J = getattr(M, "JUDGMENTS", {}) or {}
+    if not hasattr(M, "POSITIONS"):
+        return []
+    out: list = []
+    for p in M.POSITIONS:
+        if p["status"] not in ("ACTIVE", "UNDETERMINED"):
+            continue
+        cond = p["spec"]["cond"]
+        if cond is None or cond[0] not in J:
+            continue
+        if _nlit_status(M, cond) == "NEITHER":
+            out.append(_nlit_literal(hooks, cond))
+    return order_requests(out)
+
+
+def build_requests(M, blockers: list, tail: str) -> list:
+    """JudgmentRequest схемы evaluation по упорядоченным блокерам (без proof-узла)."""
+    out: list = []
+    for i, b in enumerate(blockers):
+        d = (getattr(M, "JUDGMENTS", {}) or {}).get(b["predicate"], {})
+        r = {"id": f"urn:judgment:{tail}:{i}", "predicate": b["predicate"], "authority": d.get("authority", b["predicate"]),
+             "request": {"relation": b["predicate"], "polarity": b.get("polarity", "positive"), "args": b.get("args") or []}}
+        if d.get("requestSchema") is not None:
+            r["requestSchema"] = d["requestSchema"]
+        out.append(r)
+    return out
+
+
+def judgment_blockers(M, hooks, goal: dict, status: str, conflict: bool) -> list:
+    """Порт ветвей `queries.query_truth`: цель — отношение суждения без опоры;
+    цель без опоры — тела правил и `valid_when`; стоящая цель — дефитеры головы."""
+    J = getattr(M, "JUDGMENTS", {}) or {}
+    if not J:
+        return []
+    unresolved = status == "NEITHER" and not conflict
+    if goal["predicate"] in J and unresolved:
+        return [goal]
+    if unresolved:
+        return order_requests(collect_judgments(M, hooks, goal, False) + power_judgments(M, hooks, goal))
+    if status == "TRUE_ONLY" and not conflict:
+        return order_requests(collect_judgments(M, hooks, goal, True))
+    return []
+
+
+_J_KINDS = {"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"}
+
+
+def judgment_answer(M, assertion: dict):
+    """§47.3.1 (E-0089): ответ судьи с объектом `judgment` — орган и форма payload.
+    Возвращает код issue либо None (ответ принят)."""
+    judgment = assertion.get("judgment")
+    if not isinstance(judgment, dict):
+        return None
+    pred = (assertion.get("literal") or {}).get("predicate")
+    d = (getattr(M, "JUDGMENTS", {}) or {}).get(pred, {})
+    if judgment.get("authority") != d.get("authority", pred):
+        return "JUDGMENT_AUTHORITY_MISMATCH"
+    payload = judgment.get("payload")
+    if payload is not None:
+        schema = d.get("requestSchema")
+        if schema is None:
+            return "JUDGMENT_PAYLOAD_MISMATCH"
+        want = _J_KINDS.get(str(schema.get("name")))
+        if want is not None:
+            got = _J_KINDS.get(str((payload.get("type") or {}).get("name"))) if payload.get("kind") == "value" \
+                else "entity_ref" if payload.get("kind") == "entity_ref" else "enum"
+            if got != want:
+                return "JUDGMENT_PAYLOAD_MISMATCH"
+    return None
+
+
+def admit_numeric_inputs(case, query, judgments=False):
+    # Typed request nodes only; assertion payload/metadata are not term AST.
+    stack = [query, *((a.get("literal") or {}) for a in case.get("assertions") or [])]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, list): stack.extend(node)
+        elif isinstance(node, dict):
+            if node.get("kind") == "value" and (node.get("type") or {}).get("name") == "urn:law:std#Number":
+                raise Refused("NUMBER_UNAVAILABLE: exact Number and slot narrowing (E-0316/E-0319/E-0334) are outside this slice")
+            if judgments and node.get("kind") in ("aggregate", "comprehension"):
+                raise Refused("AGGREGATE_JUDGMENT_UNAVAILABLE: open aggregate members require E-0357")
+            stack.extend(v for v in node.values() if isinstance(v, (dict, list)))