arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/ts/runtime.ts

@@ -0,0 +1,1369 @@
+// Рантайм L0 для порождённого кода. Ровно то, чего в TypeScript нет своего:
+// точная десятичная арифметика §58, деньги с валютой, названный режим
+// округления, календарный день, член перечисления.
+export type Dec = { u: bigint; s: number };              // значение = u * 10^(-s)
+export type Money = { u: bigint; s: number; cur: string };
+// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD: порядок
+// записи и есть порядок дня. Не string: у ключа атома и у сравнения свой вид.
+export type Date = { day: string };
+// Мгновение §2.15 (W2 часть 2): запись хранится как есть — идентичность атома
+// (E-0214), порядок и равенство берутся по МОМЕНТУ (E-0048): `23:01+01:00` и
+// `22:01Z` равны. Запись без смещения моментом не является: сравнивать её со
+// смещённой — отказ (§2.15), между собой такие записи сравнимы как один пояс.
+export type Instant = { at: string };
+// Член перечисления §38 либо иная ссылка const_ref без объявления: значение —
+// stable qualified identity, равенство по ней (§57), порядок не определён.
+export type Sym = { sym: string };
+// Boolean (DECISION-0266): значение первого класса; равенство по значению,
+// порядок не определён (§57), в ключе атома — свой вид, отличный от Integer 0/1.
+export type Val = string | boolean | Dec | Money | Date | Instant | Sym | Rat | Qty;
+
+// Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+// печатает его как JSON с кодом выхода 3; любая другая ошибка — крах.
+export class Refused extends Error {}
+
+const p10 = (n: number): bigint => 10n ** BigInt(n);
+
+export const dec = (lit: string): Dec => litDec(lit);
+
+export const money = (lit: string, cur: string): Money => ({ ...dec(lit), cur });
+export const date = (lit: string): Date => { dateParts(lit); return { day: lit }; };
+export const instant = (lit: string): Instant => { moment({ at: lit }); return { at: lit }; };
+export const sym = (id: string): Sym => ({ sym: id });
+
+export const isMoney = (v: Val): v is Money => typeof v === "object" && "cur" in v;
+export const isDate = (v: Val): v is Date => typeof v === "object" && "day" in v;
+export const isInstant = (v: Val): v is Instant => typeof v === "object" && "at" in v;
+export const isSym = (v: Val): v is Sym => typeof v === "object" && "sym" in v;
+export const isQty = (v: Val): v is Qty => v instanceof Qty;
+const isNum = (v: Val): v is Dec => typeof v === "object" && "u" in v;
+
+// --- виды -------------------------------------------------------------------
+
+// §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и
+// валюты, у величин — и единицы (DECISION-0256: ошибка значения).
+const same = (a: Val, b: Val, op: string): [Dec, Dec] => {
+  if (isQty(a) || isQty(b)) {
+    if (!(isQty(a) && isQty(b))) throw new TermError("TYPE_ERROR");
+    if (a.unit !== b.unit) throw new TermError("DIMENSION_MISMATCH");
+    return [a, b];
+  }
+  if (!isNum(a) || !isNum(b) || isMoney(a) !== isMoney(b)) throw new Refused("§58: виды операндов не совпадают: " + op);
+  if (isMoney(a) && isMoney(b) && a.cur !== b.cur) throw new Refused("§58: разные валюты: " + op);
+  return [a, b];
+};
+
+const boundedCoefficient = (u: bigint, s = 0): void => {
+  if (u < -(1n << 127n) || u >= (1n << 127n) || (u !== 0n && s > 4096)) throw new Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary");
+};
+const pair = (a: Dec, b: Dec): [bigint, bigint, number] => {
+  const s = Math.max(a.s, b.s), x = a.u * p10(s - a.s), y = b.u * p10(s - b.s);
+  boundedCoefficient(x, s); boundedCoefficient(y, s);
+  return [x, y, s];
+};
+
+const make = (u: bigint, s: number, like: Val): Dec => {
+  boundedCoefficient(u, s);
+  return isQty(like) ? new Qty(u, s, like.unit) : isMoney(like) ? ({ u, s, cur: like.cur } as Money) : { u, s };
+};
+
+// Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+const integral = (v: Val): v is Dec => isNum(v) && !isMoney(v) && !isQty(v) && v.u % p10(v.s) === 0n;
+const toInt = (v: Dec): bigint => v.u / p10(v.s);
+
+// --- арифметика §58 ---------------------------------------------------------
+
+export const add = (a: Val, b: Val): Dec | Rat => {
+  if (a instanceof Rat || b instanceof Rat) return ratPair(a, b, "add");
+  const [x, y] = same(a, b, "add");
+  const [px, py, s] = pair(x, y);
+  return make(px + py, s, x);
+};
+
+export const sub = (a: Val, b: Val): Dec | Rat => {
+  if (a instanceof Rat || b instanceof Rat) return ratPair(a, b, "sub");
+  const [x, y] = same(a, b, "sub");
+  const [px, py, s] = pair(x, y);
+  return make(px - py, s, x);
+};
+
+// Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+// сумма масштабов. Два размерных не перемножаются.
+export const mul = (a: Val, b: Val): Dec => {
+  if (!isNum(a) || !isNum(b)) throw new Refused("§58: виды операндов не совпадают: mul");
+  const dim = (v: Val): boolean => isMoney(v) || isQty(v);
+  if (dim(a) && dim(b)) throw new Refused("§58: произведение двух размерных величин не определено");
+  return make(a.u * b.u, a.s + b.s, dim(a) ? a : b);
+};
+
+const gcd = (a: bigint, b: bigint): bigint => {
+  a = a < 0n ? -a : a; b = b < 0n ? -b : b;
+  while (b !== 0n) { [a, b] = [b, a % b]; }
+  return a;
+};
+
+// Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе null.
+const exact = (num: bigint, den: bigint): [bigint, number] | null => {
+  const g = gcd(num, den) || 1n;
+  num /= g; den /= g;
+  if (den < 0n) { num = -num; den = -den; }
+  let twos = 0, fives = 0;
+  while (den % 2n === 0n) { den /= 2n; twos++; }
+  while (den % 5n === 0n) { den /= 5n; fives++; }
+  if (den !== 1n) return null;
+  const k = Math.max(twos, fives);
+  return [num * (2n ** BigInt(k - twos)) * (5n ** BigInt(k - fives)), k];
+};
+
+// Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+// валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+export const div = (a: Val, b: Val): Dec => {
+  if (!isNum(a) || !isNum(b)) throw new Refused("§58: деление вне таблицы делимых");
+  if (b.u === 0n) throw new Refused("деление на ноль — evaluation error (§58)");
+  let like: Money | null = null;
+  if (isMoney(a) && isMoney(b)) {
+    if (a.cur !== b.cur) throw new Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте");
+  } else if (isMoney(a)) {
+    like = a;
+  } else if (isMoney(b)) {
+    throw new Refused("§58: деление вне таблицы делимых");
+  }
+  const q = exact(a.u * p10(b.s), b.u * p10(a.s));
+  if (q === null) {
+    if (like !== null) throw new Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)");
+    throw new Refused("§58: частное не 10-гладкое — Rational вне среза");
+  }
+  return like !== null ? ({ u: q[0], s: q[1], cur: like.cur } as Money) : { u: q[0], s: q[1] };
+};
+
+// Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+export const mod = (a: Val, b: Val): Dec => {
+  if (!integral(a) || !integral(b)) throw new Refused("§58: mod определён только для Integer");
+  const y = toInt(b);
+  if (y === 0n) throw new Refused("остаток от деления на ноль — evaluation error (§58)");
+  const m = y < 0n ? -y : y;
+  const r = ((toInt(a) % m) + m) % m;
+  return { u: r, s: 0 };
+};
+
+// --- Rational §35/§58 и арифметика по видам (DECISION-0252) ------------------
+
+// Quantity §49 v1 (DECISION-0256 п. 5): точное десятичное и тег единицы —
+// байты записи; реестра единиц и алиасов §49.2 здесь нет. Не Money: у ключа
+// и у сравнения свой вид, 1 KZT денег и величина 1 [KZT] — разные значения.
+export class Qty {
+  readonly u: bigint;
+  readonly s: number;
+  readonly unit: string;
+  constructor(u: bigint, s: number, unit: string) {
+    this.u = u;
+    this.s = s;
+    this.unit = unit;
+  }
+}
+
+// Величина §49: значение и тег единицы как записаны.
+export const qty = (lit: string, unit: string): Qty => {
+  const d = dec(lit);
+  return new Qty(d.u, d.s, String(unit));
+};
+
+// Rational §35 (DECISION-0252 п. 6): несократимая дробь на целых произвольной
+// длины, знаменатель положителен, ноль — 0/1. Не Dec: у ключа строки и у
+// сравнения свой вид, 2/1 и Decimal 2 — разные значения §48.
+export class Rat {
+  readonly n: bigint;
+  readonly d: bigint;
+  constructor(n: bigint, d: bigint) {
+    if (d === 0n) throw new TermError("DIVISION_BY_ZERO");
+    if (d < 0n) { n = -n; d = -d; }
+    const g = gcd(n, d) || 1n;
+    this.n = n / g;
+    this.d = d / g;
+  }
+}
+
+// --- сырое поле литерала §208 -------------------------------------------------
+// Правило одно на три цели (errata E-0197, E-0202, E-0203): сырое поле литерала
+// читается НЕ средствами языка цели, а по грамматике §208. `Number()` и
+// `parseFloat` берут `1e2` и `Infinity` и теряют точность выше 2^53; `int()` и
+// `Decimal()` Python берут пробел, `_` и юникодную цифру; `math/big` Go — свои
+// допуски. Норма у всех одна, поэтому алфавит назван явно и одинаково.
+
+// §18/§208 (errata E-0203): лексика ЗАПИСИ десятичного значения — дословный
+// порт `lawref/values.py::_DECIMAL_LEXIS`. Экспонента, ведущие и хвостовые
+// нули, знак `+`, `.5` и `5.` остаются законной записью входа и нормализуются;
+// сужены ровно пробельный символ, `_`, не-ASCII цифра и `Infinity`/`NaN`.
+// В JavaScript `$` без флага `m` уже строг — хвостового перевода строки, из-за
+// которого оракулу понадобился `\Z`, он не пропускает.
+const DECIMAL_LEXIS = /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;
+// §35/§208 (errata E-0203): лексика ЦЕЛОГО внутри записи `<n>/<d>`.
+const FRACTION_PART_LEXIS = /^[+-]?[0-9]+$/;
+// §208 (errata E-0202): знаковый 64-битный носитель JSON-числа канона.
+const I64_MIN = -(2n ** 63n), I64_MAX = 2n ** 63n - 1n;
+// Канон §208 отвергает JSON-float и целое вне i64 ОТКАЗОМ СОБРАТЬ ДОКУМЕНТ
+// (error-объект §172), а не issue. У порождённого модуля канала error-объекта
+// нет — профиль core-executable документа не строит, — поэтому тот же вход даёт
+// названный отказ раннера: «меньше ответа», а не другой ответ.
+export const CANON_NUMBER = "JSON-число вне канона §208 (только целое знакового 64-битного диапазона) вне среза раннера";
+
+// Вид JSON-носителя сырого поля литерала и его текст: "s" — JSON-строка,
+// "i" — целое JSON-число канона, "x" — любая другая форма (в том числе
+// отсутствие поля: схема LiteralTerm не требует `value`, E-0197).
+export const rawLit = (raw: any): [string, string] => {
+  if (typeof raw === "string") return ["s", raw];
+  if (typeof raw === "boolean") return ["x", ""];
+  // Носитель точного целого из parseJson: {"int":"<цифры>"} — та же запись, в
+  // которой раннер целое и ПЕЧАТАЕТ, и которую читает харнесс API.
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw)
+      && Object.keys(raw).length === 1 && typeof raw.int === "string") {
+    const v = BigInt(raw.int);
+    if (v < I64_MIN || v > I64_MAX) throw new Refused(CANON_NUMBER);
+    return ["i", v.toString()];
+  }
+  if (typeof raw === "number") {
+    if (!Number.isInteger(raw)) throw new Refused(CANON_NUMBER);
+    return ["i", BigInt(raw).toString()];
+  }
+  return ["x", ""];
+};
+
+// Поле, чей канон §208 — JSON-строка (Text, Date, Instant, Rational, валюта,
+// единица). Порт `values._json_string`: до E-0197 цели приводили к строке ЛЮБОЙ
+// JSON, и литерал без `value` выходил значением "undefined" у ts и "" у go —
+// расхождение в результате, а не в тексте issue.
+export const litText = (raw: any): string => {
+  const [k, text] = rawLit(raw);
+  if (k !== "s") throw new TermError("TYPE_ERROR");
+  return text;
+};
+
+// Поле, чей канон §208 — целое JSON-число (Integer). Порт `values._json_int`.
+export const litIntText = (raw: any): string => {
+  const [k, text] = rawLit(raw);
+  if (k !== "i") throw new TermError("TYPE_ERROR");
+  return text;
+};
+
+// Поле Decimal/Money/Quantity: строка по лексике §208 либо целое JSON-число
+// (запись числом остаётся законной — E-0203, долг п. 3).
+export const litDecText = (raw: any): string => {
+  const [k, text] = rawLit(raw);
+  if (k === "i") return text;
+  if (k !== "s" || !DECIMAL_LEXIS.test(text)) throw new TermError("TYPE_ERROR");
+  return text;
+};
+
+// Точное десятичное из записи, уже прошедшей DECIMAL_LEXIS: знак, необязательная
+// экспонента, `.5` и `5.`. Нормализация — как у `Decimal(text)` оракула, чей
+// канон §208 печатает non-exponent форму.
+export const decLexis = (text: string): Dec => {
+  let body = text;
+  const neg = body.startsWith("-");
+  if (body.startsWith("+") || body.startsWith("-")) body = body.slice(1);
+  const at = body.search(/[eE]/);
+  const exp = at < 0 ? 0 : Number(body.slice(at + 1));
+  const mant = at < 0 ? body : body.slice(0, at);
+  const dot = mant.indexOf(".");
+  const frac = dot < 0 ? "" : mant.slice(dot + 1);
+  const digits = ((dot < 0 ? mant : mant.slice(0, dot)) + frac) || "0";
+  let s = frac.length - exp, u = BigInt(digits);
+  if (u === 0n && Math.abs(s) > 4096) return { u: 0n, s: 0 };
+  const canonicalScale = s - (digits.length - digits.replace(/0+$/, "").length);
+  if (u !== 0n && (canonicalScale > 4096 || s < -4096)) throw new Refused("DECIMAL_EXPANSION_UNAVAILABLE: E-0320 limit 4096");
+  if (s < 0) { u *= 10n ** BigInt(-s); s = 0; }
+  return { u: neg ? -u : u, s };
+};
+
+export const litDec = (raw: any): Dec => decLexis(litDecText(raw));
+export const litInt = (raw: any): Dec => ({ u: BigInt(litIntText(raw)), s: 0 });
+export const litMoney = (raw: any, cur: any): Money => ({ ...litDec(raw), cur: litText(cur) });
+export const litQty = (raw: any, unit: any): Qty => {
+  const d = litDec(raw);
+  return new Qty(d.u, d.s, litText(unit));
+};
+
+// Каноническая запись `n/d` (§168.1): иная — названный отказ, а не молчаливое
+// сокращение — оракул хранит запись как есть, и сокращённая дала бы другой ответ.
+export const rat = (lit: any): Rat => {
+  const text = litText(lit);
+  const at = text.indexOf("/");
+  const num = at < 0 ? text : text.slice(0, at), den = at < 0 ? "" : text.slice(at + 1);
+  if (!FRACTION_PART_LEXIS.test(num) || !FRACTION_PART_LEXIS.test(den)) {
+    throw new Refused("§168.1: запись Rational не n/d: " + text);
+  }
+  const n = BigInt(num), d = BigInt(den);
+  if (d <= 0n || gcd(n, d) !== 1n || `${n}/${d}` !== text) throw new Refused("§168.1: неканоническая запись Rational: " + text);
+  return new Rat(n, d);
+};
+
+// Литерал Rational в вычислимом терме вопроса `term`: разбор оракула
+// (`values.from_literal_term`) — запись `n/d` с целыми частями по лексике §208
+// (E-0203), сократимая и со знаком в знаменателе нормализуется; не `n/d` —
+// TYPE_ERROR, знаменатель 0 — DIVISION_BY_ZERO. Каноничность §168.1 требуется
+// от записей дела и вопроса `truth`, не от операнда вычисления (ERR-E0005).
+export const ratTerm = (lit: any): Rat => {
+  const parts = litText(lit).split("/");
+  if (parts.length !== 2 || !FRACTION_PART_LEXIS.test(parts[0]) || !FRACTION_PART_LEXIS.test(parts[1])) {
+    throw new TermError("TYPE_ERROR");
+  }
+  const n = BigInt(parts[0]), d = BigInt(parts[1]);
+  if (d === 0n) throw new TermError("DIVISION_BY_ZERO");
+  return new Rat(n, d);
+};
+
+// §208/§18 (errata E-0202): `JSON.parse` сводит число к double, и целое
+// знакового 64-битного диапазона теряет знаки уже НА ЧТЕНИИ —
+// 9223372036854775807 приходило в раннер как 9223372036854776000, то есть
+// ДРУГИМ ответом, а не меньшим. Число разбирается по тексту: целое, которого
+// `Number` не несёт точно, заменяется носителем {"int":"<цифры>"}. Строки
+// проходятся отдельной ветвью, поэтому цифры ВНУТРИ строки не трогаются.
+const NUM_TOKEN = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?/y;
+const SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+export const parseJson = (text: string): any => {
+  const out: string[] = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length) {
+        if (text[j] === "\\") { j += 2; continue; }
+        if (text[j] === '"') { j += 1; break; }
+        j += 1;
+      }
+      out.push(text.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === "-" || (ch >= "0" && ch <= "9")) {
+      NUM_TOKEN.lastIndex = i;
+      const m = NUM_TOKEN.exec(text);
+      if (m !== null && m.index === i) {
+        const tok = m[0];
+        const plain = !/[.eE]/.test(tok);
+        const big = plain && (BigInt(tok) > SAFE || BigInt(tok) < -SAFE);
+        out.push(big ? `{"int":${JSON.stringify(tok)}}` : tok);
+        i += tok.length;
+        continue;
+      }
+    }
+    out.push(ch);
+    i += 1;
+  }
+  return JSON.parse(out.join(""));
+};
+
+// Целая часть с округлением вниз — `//` эталона; BigInt `/` усекает к нулю.
+const floorDiv = (a: bigint, b: bigint): bigint => {
+  const q = a / b;
+  return a % b !== 0n && (a < 0n) !== (b < 0n) ? q - 1n : q;
+};
+const intOf = (v: Dec): bigint => floorDiv(v.u, p10(v.s));
+
+// add/sub/min/max над Rational: оба операнда Rational, иначе TYPE_ERROR §48.
+const ratPair = (a: Val, b: Val, op: string): Rat => {
+  if (!(a instanceof Rat && b instanceof Rat)) throw new TermError("TYPE_ERROR");
+  if (op === "add") return new Rat(a.n * b.d + b.n * a.d, a.d * b.d);
+  if (op === "sub") return new Rat(a.n * b.d - b.n * a.d, a.d * b.d);
+  if (op === "min") return a.n * b.d <= b.n * a.d ? a : b;
+  return a.n * b.d >= b.n * a.d ? a : b;
+};
+
+// Вид значения динамического терма (DECISION-0252 п. 5): `r` Rational, `d` Decimal.
+export const kindOf = (v: Val): string => (v instanceof Rat ? "r" : "d");
+
+const KINDS = ["i", "d", "m", "r", "q"];
+
+// Статический вид плана → вид значения; `n` — Decimal либо Rational по классу.
+const resolve = (v: Val, k: string): string => {
+  if (k === "n") k = v instanceof Rat ? "r" : "d";
+  if (!KINDS.includes(k) || (k === "r") !== (v instanceof Rat) || (k === "m") !== isMoney(v)
+      || (k === "q") !== isQty(v)) {
+    throw new Refused("вид операнда расходится с планом: " + String(k));
+  }
+  return k;
+};
+
+// Точное десятичное num/den (§18) видом `like` (Money, Quantity либо Dec) или null.
+const exactOf = (num: bigint, den: bigint, like: Val | null): Dec | null => {
+  const q = exact(num, den);
+  if (q === null) return null;
+  if (like !== null && isQty(like)) return new Qty(q[0], q[1], like.unit);
+  return like !== null && isMoney(like) ? ({ u: q[0], s: q[1], cur: like.cur } as Money) : { u: q[0], s: q[1] };
+};
+
+// Таблица §58 `values.binary` по видам операндов (DECISION-0252 п. 3–4).
+// Виды — из плана: `i` Integer, `d` Decimal, `m` Money, `r` Rational, `n` —
+// Decimal либо Rational по значению. Integer и Decimal рантайм по значению не
+// различает, поэтому пара решается видами, а не классами. Ошибка значения —
+// TermError с кодом оракула, в его порядке проверок.
+const arithUnchecked = (op: string, a: Val, b: Val, lk: string, rk: string): Val => {
+  const l = resolve(a, lk), r = resolve(b, rk);
+  const has = (k: string): boolean => l === k || r === k;
+  const pairIs = (x: string, y: string): boolean => (l === x && r === y) || (l === y && r === x);
+  if (op === "add" || op === "sub") {
+    if (l === "m" && r === "m" && (a as Money).cur !== (b as Money).cur) throw new TermError("CURRENCY_MISMATCH");
+    if (l === "q" && r === "q" && (a as Qty).unit !== (b as Qty).unit) throw new TermError("DIMENSION_MISMATCH"); // §49, T023
+    if (l !== r) throw new TermError("TYPE_ERROR");
+    if (l === "r") return ratPair(a, b, op);
+    return op === "add" ? add(a, b) : sub(a, b);
+  }
+  if (op === "mul") {
+    if ((l === "i" && r === "i") || (has("i") && (has("m") || has("d") || has("q")))) return mul(a, b);
+    if (pairIs("i", "r")) {
+      const [q, k] = l === "r" ? [a as Rat, b as Dec] : [b as Rat, a as Dec];
+      return new Rat(q.n * intOf(k), q.d);
+    }
+    if (has("i")) throw new TermError("TYPE_ERROR");
+    if (l === "r" && r === "r") return new Rat((a as Rat).n * (b as Rat).n, (a as Rat).d * (b as Rat).d);
+    if (pairIs("m", "r")) {
+      // E-0085: доля масштабирует деньги точно; 10-гладкость — после сокращения.
+      const [m, q] = l === "m" ? [a as Money, b as Rat] : [b as Money, a as Rat];
+      const out = exactOf(m.u * q.n, p10(m.s) * q.d, m);
+      if (out === null) throw new TermError("INEXACT_DIVISION");
+      return out;
+    }
+    if (has("r") || (l === "m" && r === "m") || (l === "q" && r === "q") || pairIs("m", "q")) throw new TermError("TYPE_ERROR");
+    return mul(a, b);
+  }
+  if (op === "div") {
+    if (l === "r" && r === "r") {
+      const x = a as Rat, y = b as Rat;
+      if (y.n === 0n) throw new TermError("DIVISION_BY_ZERO");
+      return new Rat(x.n * y.d, x.d * y.n);
+    }
+    if (l === "i" && r === "i") {
+      if (intOf(b as Dec) === 0n) throw new TermError("DIVISION_BY_ZERO");
+      return new Rat(intOf(a as Dec), intOf(b as Dec));
+    }
+    if (has("r")) throw new TermError("TYPE_ERROR");
+    const x = a as Dec, y = b as Dec;
+    const num = x.u * p10(y.s), den = y.u * p10(x.s);
+    if (l === "m" && r === "m") {
+      // E-0083: частное сумм одной валюты безразмерно — Decimal либо Rational.
+      if ((a as Money).cur !== (b as Money).cur) throw new TermError("CURRENCY_MISMATCH");
+      if (y.u === 0n) throw new TermError("DIVISION_BY_ZERO");
+      return exactOf(num, den, null) ?? new Rat(num, den);
+    }
+    if (l === "q" && r === "q") {
+      // E-0068: частное одной единицы безразмерно; разные единицы — TYPE_ERROR раньше нуля.
+      if ((a as Qty).unit !== (b as Qty).unit) throw new TermError("TYPE_ERROR");
+      if (y.u === 0n) throw new TermError("DIVISION_BY_ZERO");
+      return exactOf(num, den, null) ?? new Rat(num, den);
+    }
+    if (!((l === "d" && r === "d") || (l === "m" && r === "d") || (l === "q" && r === "d"))) throw new TermError("TYPE_ERROR");
+    if (y.u === 0n) throw new TermError("DIVISION_BY_ZERO");
+    const out = exactOf(num, den, a);
+    if (out !== null) return out;
+    if (l === "d") return new Rat(num, den);
+    throw new TermError("INEXACT_DIVISION");
+  }
+  if (op === "mod") {
+    if (l === "i" && r === "i") {
+      const yv = intOf(b as Dec);
+      if (yv === 0n) throw new TermError("DIVISION_BY_ZERO");
+      const m = yv < 0n ? -yv : yv;
+      return { u: ((intOf(a as Dec) % m) + m) % m, s: 0 };
+    }
+    throw new TermError("TYPE_ERROR");
+  }
+  throw new Refused("операция вне среза рантайма: " + String(op));
+};
+
+export const min = (a: Val, b: Val): Dec | Rat => {
+  if (a instanceof Rat || b instanceof Rat) return ratPair(a, b, "min");
+  const [x, y] = same(a, b, "min");
+  const [px, py] = pair(x, y);
+  return px <= py ? x : y;
+};
+
+export const max = (a: Val, b: Val): Dec | Rat => {
+  if (a instanceof Rat || b instanceof Rat) return ratPair(a, b, "max");
+  const [x, y] = same(a, b, "max");
+  const [px, py] = pair(x, y);
+  return px >= py ? x : y;
+};
+
+export const arith = (op: string, a: Val, b: Val, lk: string, rk: string): Val => {
+  for (const v of [a, b]) if (isNum(v)) boundedCoefficient(v.u, v.s);
+  const out = arithUnchecked(op, a, b, lk, rk);
+  if (isNum(out)) {
+    boundedCoefficient(out.u, out.s);
+    if (lk === "i" && rk === "i" && ["add", "sub", "mul", "mod"].includes(op) && (out.u < -(1n << 63n) || out.u >= (1n << 63n))) throw new Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary");
+  }
+  return out;
+};
+
+export const abs = (v: Val): Dec | Rat => {
+  if (isNum(v) && v.s === 0 && v.u === -(1n << 63n)) throw new Refused("NUMERIC_LIMIT_UNAVAILABLE: current i64/i128 arithmetic boundary");
+  if (v instanceof Rat) return new Rat(v.n < 0n ? -v.n : v.n, v.d);
+  if (!isNum(v)) throw new Refused("§58: abs — не числовой вид");
+  return make(v.u < 0n ? -v.u : v.u, v.s, v);
+};
+
+const POW_EXP_LIMIT = 4096n;
+const POW_MIN = -(2n ** 63n);
+const POW_MAX = 2n ** 63n - 1n;
+
+// §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+// вычисление, диапазон — часть контракта.
+export const pow = (base: Val, exp: Val): Dec => {
+  if (!integral(base) || !integral(exp)) throw new Refused("§58: pow определён только для Integer");
+  const e = toInt(exp);
+  if (e < 0n) throw new Refused("§58: pow — показатель отрицателен");
+  if (e > POW_EXP_LIMIT) throw new Refused("RESOURCE_LIMIT: pow — показатель превышает 4096");
+  const r = toInt(base) ** e;
+  if (r < POW_MIN || r > POW_MAX) throw new Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+  return { u: r, s: 0 };
+};
+
+export const round = (m: Val, digitsIn: number | Val, mode: string): Dec => {
+  if (mode !== "HALF_UP") throw new Refused("§50: режим округления не реализован: " + mode);
+  if (!isNum(m)) throw new Refused("§50: round — не числовой вид");
+  const digits = typeof digitsIn === "number" ? digitsIn
+    : isNum(digitsIn) ? Number(digitsIn.u / p10(digitsIn.s)) : 0;
+  if (m.s <= digits) return make(m.u * p10(digits - m.s), digits, m);
+  const drop = p10(m.s - digits);
+  const neg = m.u < 0n;
+  const a = neg ? -m.u : m.u;
+  const q = a / drop;
+  const r = a % drop;
+  const up = r * 2n >= drop ? q + 1n : q;                // HALF_UP — от нуля
+  return make(neg ? -up : up, digits, m);
+};
+
+// --- политика округления §50 (DECISION-0259) ---------------------------------
+
+const ROUNDING_MODES = ["CEILING", "DOWN", "FLOOR", "HALF_DOWN", "HALF_EVEN", "HALF_UP", "UP"];
+const DIV_ROUND_MAX_PRECISION = 34n;
+
+// Порт `values._round_fraction` на целых: num/den (den > 0) к целому по режиму
+// §50; `2*tail` против знаменателя, ветви в порядке оракула.
+const roundInt = (num: bigint, den: bigint, mode: string): bigint => {
+  const negative = num < 0n;
+  const a = negative ? -num : num;
+  let head = a / den;
+  const tail = a % den;
+  let up: boolean;
+  switch (mode) {
+    case "HALF_UP": up = 2n * tail >= den; break;
+    case "HALF_EVEN": up = 2n * tail > den || (2n * tail === den && head % 2n === 1n); break;
+    case "HALF_DOWN": up = 2n * tail > den; break;
+    case "UP": up = tail > 0n; break;
+    case "DOWN": up = false; break;
+    case "CEILING": up = tail > 0n && !negative; break;
+    case "FLOOR": up = tail > 0n && negative; break;
+    default: throw new Refused("§50: режим округления не реализован: " + mode);
+  }
+  if (up) head += 1n;
+  return negative ? -head : head;
+};
+
+// Точность политики: Integer либо целый Decimal, вид — из плана. Дробная
+// точность — TYPE_ERROR; проверка на целом bigint до любого перевода в Number.
+const policyScale = (p: Val, pk: string): bigint => {
+  if (pk !== "i" && pk !== "d") throw new Refused("вид точности расходится с планом: " + String(pk));
+  resolve(p, pk);
+  const d = p as Dec;
+  if (d.u % p10(d.s) !== 0n) throw new TermError("TYPE_ERROR");
+  return d.u / p10(d.s);
+};
+
+const policyMode = (mode: Val): string => {
+  if (typeof mode !== "string" || !ROUNDING_MODES.includes(mode)) throw new TermError("TYPE_ERROR");
+  return mode;
+};
+
+// §50 `round` с проверкой политики (DECISION-0259 п. 4, 7): порядок
+// `values.round_value` — вид, точность (целое >= 0), режим. Integer — тождество
+// (E-0110); точность не короче дробной части — значение то же (E-0184).
+export const round_mode = (v: Val, p: Val, mode: Val, vk: string, pk: string): Val => {
+  const k = resolve(v, vk);
+  if (k === "r") throw new TermError("TYPE_ERROR");
+  const scale = policyScale(p, pk);
+  if (scale < 0n) throw new TermError("TYPE_ERROR");
+  const m = policyMode(mode);
+  const x = v as Dec;
+  if (k === "i" || scale >= BigInt(x.s)) return v;
+  const s = Number(scale);                               // s < x.s: перевод точен
+  return make(roundInt(x.u, p10(x.s - s), m), s, v);
+};
+
+// §50/§58 `div_round` (E-0036, E-0170; DECISION-0259 п. 4, 7): пара → валюта →
+// ноль → точность 0..34 → режим. Частное точное, округление всегда;
+// Money/Money — доля Decimal без тега.
+export const div_round = (a: Val, b: Val, p: Val, mode: Val, ak: string, bk: string, pk: string): Val => {
+  const l = resolve(a, ak), r = resolve(b, bk);
+  if (!((l === "m" && r === "d") || (l === "q" && r === "d") || (l === "d" && r === "d") || (l === "m" && r === "m"))) {
+    throw new TermError("TYPE_ERROR");
+  }
+  if (l === "m" && r === "m" && (a as Money).cur !== (b as Money).cur) throw new TermError("CURRENCY_MISMATCH");
+  const x = a as Dec, y = b as Dec;
+  if (y.u === 0n) throw new TermError("DIVISION_BY_ZERO");
+  const scale = policyScale(p, pk);
+  if (!(scale >= 0n && scale <= DIV_ROUND_MAX_PRECISION)) throw new TermError("TYPE_ERROR");
+  const m = policyMode(mode);
+  const s = Number(scale);
+  let num = x.u * p10(y.s + s), den = y.u * p10(x.s);
+  if (den < 0n) { num = -num; den = -den; }
+  const q = roundInt(num, den, m);
+  return r === "m" ? { u: q, s } : make(q, s, a);
+};
+
+// --- сравнение и равенство ---------------------------------------------------
+
+export const eq = (a: Val, b: Val): boolean => {
+  if (typeof a === "boolean" || typeof b === "boolean") return typeof a === "boolean" && typeof b === "boolean" && a === b;
+  if (a instanceof Rat || b instanceof Rat) return a instanceof Rat && b instanceof Rat && a.n === b.n && a.d === b.d;
+  if (isQty(a) || isQty(b)) {
+    if (!(isQty(a) && isQty(b)) || a.unit !== b.unit) return false;
+    const [x, y] = pair(a, b);
+    return x === y;
+  }
+  if (isSym(a) || isSym(b)) return isSym(a) && isSym(b) && a.sym === b.sym;
+  if (isDate(a) || isDate(b)) return isDate(a) && isDate(b) && a.day === b.day;
+  if (isInstant(a) || isInstant(b)) return isInstant(a) && isInstant(b) && momentCmp(a, b, "eq") === 0;
+  if (typeof a === "string" || typeof b === "string") return a === b;
+  if (isMoney(a) !== isMoney(b)) return false;
+  if (isMoney(a) && isMoney(b) && a.cur !== b.cur) return false;
+  const [x, y] = pair(a as Dec, b as Dec);
+  return x === y;
+};
+
+export const cmp = (a: Val, op: string, b: Val): boolean => {
+  if (typeof a === "boolean" || typeof b === "boolean") {
+    // §57 (DECISION-0266): Boolean сравнимо только на равенство и только с Boolean.
+    const sameBool = typeof a === "boolean" && typeof b === "boolean" && a === b;
+    if (op === "eq") return sameBool;
+    if (op === "ne") return !sameBool;
+    throw new Refused("§57: вид Boolean не упорядочен");
+  }
+  if (a instanceof Rat || b instanceof Rat) {
+    // §57/§48 (DECISION-0252 п. 6): Rational сравнивается только с Rational;
+    // иной вид — TYPE_ERROR оракула, а не false.
+    if (!(a instanceof Rat && b instanceof Rat)) throw new TermError("TYPE_ERROR");
+    const x = a.n * b.d, y = b.n * a.d;
+    switch (op) {
+      case "lt": return x < y;
+      case "le": return x <= y;
+      case "gt": return x > y;
+      case "ge": return x >= y;
+      case "eq": return x === y;
+      case "ne": return x !== y;
+      default: throw new Refused("сравнение вне среза рантайма: " + op);
+    }
+  }
+  if (isQty(a) || isQty(b)) {
+    // §49/§57 (DECISION-0256 п. 5): величина — только с величиной той же единицы.
+    const [qa, qb] = same(a, b, "cmp");
+    const [x, y] = pair(qa, qb);
+    switch (op) {
+      case "lt": return x < y;
+      case "le": return x <= y;
+      case "gt": return x > y;
+      case "ge": return x >= y;
+      case "eq": return x === y;
+      case "ne": return x !== y;
+      default: throw new Refused("сравнение вне среза рантайма: " + op);
+    }
+  }
+  if (isSym(a) || isSym(b)) {
+    const sameSym = isSym(a) && isSym(b) && a.sym === b.sym;
+    if (op === "eq") return sameSym;
+    if (op === "ne") return !sameSym;
+    throw new Refused("§57: вид enum не упорядочен");
+  }
+  if (isInstant(a) || isInstant(b)) {
+    if (isInstant(a) && isInstant(b)) {
+      const c = momentCmp(a, b, op);
+      switch (op) {
+        case "lt": return c < 0;
+        case "le": return c <= 0;
+        case "gt": return c > 0;
+        case "ge": return c >= 0;
+        case "eq": return c === 0;
+        case "ne": return c !== 0;
+        default: throw new Refused("сравнение вне среза рантайма: " + op);
+      }
+    }
+    // §57/§2.15: Date и Instant не сравниваются (DATE_INSTANT_MISMATCH оракула).
+    throw new Refused("§57: Instant сравнивается только с Instant");
+  }
+  if (isDate(a) || isDate(b)) {
+    if (isDate(a) && isDate(b)) {
+      switch (op) {
+        case "lt": return a.day < b.day;
+        case "le": return a.day <= b.day;
+        case "gt": return a.day > b.day;
+        case "ge": return a.day >= b.day;
+        case "eq": return a.day === b.day;
+        case "ne": return a.day !== b.day;
+        default: throw new Refused("сравнение вне среза рантайма: " + op);
+      }
+    }
+    if (op === "eq") return false;
+    if (op === "ne") return true;
+    throw new Refused("§57: Date сравнивается только с Date");
+  }
+  if (typeof a === "string" || typeof b === "string") {
+    if (op === "eq") return a === b;
+    if (op === "ne") return a !== b;
+    throw new Refused("порядок на Text вне среза рантайма: " + op);
+  }
+  if (isMoney(a) !== isMoney(b)) throw new Refused("§49: сравнение денег с безразмерным");
+  if (isMoney(a) && isMoney(b) && a.cur !== b.cur) throw new Refused("§49: разные валюты");
+  const [x, y] = pair(a as Dec, b as Dec);
+  switch (op) {
+    case "lt": return x < y;
+    case "le": return x <= y;
+    case "gt": return x > y;
+    case "ge": return x >= y;
+    case "eq": return x === y;
+    case "ne": return x !== y;
+    default: throw new Refused("сравнение вне среза рантайма: " + op);
+  }
+};
+
+const norm = (d: Dec): string => {
+  let { u, s } = d;
+  if (u === 0n) return "0e-0";
+  while (s > 0 && u % 10n === 0n) { u /= 10n; s -= 1; }
+  return u.toString() + "e-" + s;
+};
+
+// Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+// ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+const esc = (text: string): string => text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+
+export const key = (row: Val[]): string =>
+  row.map((v) => (typeof v === "string" ? "e:" + esc(v) : typeof v === "boolean" ? "b:" + (v ? "true" : "false") : isSym(v) ? "c:" + esc(v.sym) : isDate(v) ? "t:" + v.day : isInstant(v) ? "i:" + esc(v.at)
+    : v instanceof Rat ? "r:" + v.n.toString() + "/" + v.d.toString()
+    : isQty(v) ? "q:" + esc(v.unit) + ":" + norm(v)
+    : isMoney(v) ? "m:" + v.cur + ":" + norm(v) : "d:" + norm(v))).join("|");
+
+// Контекст одного вычисления (DECISION-0423 §2.3): правовое время дела (правило
+// вне окна `effective` не применяется), политика срока §86 и снимок календаря
+// §85. `evaluate` синхронен: он ставит свежий контекст на время вызова и в
+// `finally` возвращает прежний, поэтому состояние вызова его не переживает.
+type Context = { legalTime: string; policy: Policy | null; snapshot: Snapshot | null };
+const freshContext = (): Context => ({ legalTime: "", policy: null, snapshot: null });
+let CTX: Context = freshContext();
+export const beginContext = (): Context => { const prev = CTX; CTX = freshContext(); return prev; };
+export const endContext = (prev: Context): void => { CTX = prev; };
+export const setLegalTime = (t: string): void => { CTX.legalTime = t; };
+export const legalTime = (): string => {
+  if (!CTX.legalTime) throw new Refused("legalTime не подан делом");
+  return CTX.legalTime;
+};
+
+// --- календарь §84–§86 (DECISION-0245) ---------------------------------------
+// Порт `lawref.values` и `lawref.calendar` дословно по порядку проверок: код
+// ошибки — часть ответа (issue модели). Даты — ISO-строки, арифметика дней в UTC.
+
+export class TermError extends Error { constructor(public code: string) { super(code); } }
+
+export type Snapshot = { id: string; error?: string; start?: string; endExclusive?: string;
+  weekly?: boolean[]; overrides?: Record<string, boolean> };
+type Policy = Record<string, any>;
+export const setCalendar = (policy: Policy | null, snapshot: Snapshot | null): void => {
+  CTX.policy = policy; CTX.snapshot = snapshot;
+};
+
+// Date.UTC сдвигает годы 0–99 на 1900: полная дата ставится setUTCFullYear.
+const utc = (y: number, m: number, d: number): number => {
+  const t = new globalThis.Date(0);
+  t.setUTCFullYear(y, m, d);
+  return t.getTime();
+};
+const ms = (iso: string): number => utc(+iso.slice(0, 4), +iso.slice(5, 7) - 1, +iso.slice(8, 10));
+const iso = (t: number): string => {
+  const d = new globalThis.Date(t);
+  return String(d.getUTCFullYear()).padStart(4, "0") + "-" + String(d.getUTCMonth() + 1).padStart(2, "0")
+    + "-" + String(d.getUTCDate()).padStart(2, "0");
+};
+const plusDays = (day: string, n: number): string => iso(ms(day) + n * 86400000);
+
+const calendar = (): Snapshot => {
+  const snap = CTX.snapshot;
+  if (snap === null || snap.error === "MISSING_CALENDAR") throw new TermError("MISSING_CALENDAR");
+  if (snap.error !== undefined) throw new TermError(snap.error);
+  return snap;
+};
+const coverage = (cal: Snapshot, day: string): void => {
+  if (!((cal.start as string) <= day && day < (cal.endExclusive as string))) throw new TermError("CALENDAR_OUT_OF_RANGE");
+};
+const working = (cal: Snapshot, day: string): boolean => {
+  coverage(cal, day);
+  const o = (cal.overrides as Record<string, boolean>)[day];
+  if (o !== undefined) return o;
+  return (cal.weekly as boolean[])[(new globalThis.Date(ms(day)).getUTCDay() + 6) % 7];
+};
+const previousWorking = (cal: Snapshot, day: string): string => {
+  coverage(cal, day);
+  let current = plusDays(day, -1);
+  for (;;) {
+    coverage(cal, current);
+    if (working(cal, current)) return current;
+    current = plusDays(current, -1);
+  }
+};
+const nextWorking = (cal: Snapshot, day: string): string => {
+  while (!working(cal, day)) { day = plusDays(day, 1); coverage(cal, day); }
+  return day;
+};
+const lastDay = (year: number, month: number): number => new globalThis.Date(utc(year, month, 0)).getUTCDate();
+const pad = (n: number, w: number): string => String(n).padStart(w, "0");
+const addMonths = (day: string, months: number, monthEnd: string): string => {
+  const total = +day.slice(5, 7) - 1 + months;
+  const year = +day.slice(0, 4) + Math.floor(total / 12), month = ((total % 12) + 12) % 12 + 1;
+  const last = lastDay(year, month), d = +day.slice(8, 10);
+  if (d <= last) return `${pad(year, 4)}-${pad(month, 2)}-${pad(d, 2)}`;
+  if (monthEnd === "last_day_of_month") return `${pad(year, 4)}-${pad(month, 2)}-${pad(last, 2)}`;
+  throw new TermError("DEADLINE_POLICY_INVALID");
+};
+const CAL_UNITS = ["calendar_month", "calendar_year"];
+const needsCalendar = (unit: string, policy: Policy | null): boolean => {
+  if (![...CAL_UNITS, "calendar_week"].includes(unit)) return true;
+  const p = policy ?? {};
+  return p.roll !== "no_roll" || p.include_end !== true;
+};
+const FIELDS = new Set(["start_count", "include_end", "roll", "cutoff", "month_end"]);
+
+// Порт `calendar.compute_deadline` без приостановлений (терм их не несёт).
+const deadline = (cal: Snapshot | null, after: string, count: number, policy: Policy | null,
+  afterTime: string | null, unit: string, calendarDayStep = false): string => {
+  if (policy === null) throw new TermError("MISSING_POLICY");
+  if (Object.keys(policy).some((k) => !FIELDS.has(k))) throw new TermError("DEADLINE_POLICY_INVALID");
+  const startCount = policy.start_count, roll = policy.roll, includeEnd = policy.include_end;
+  const cutoff = policy.cutoff === undefined ? null : policy.cutoff;
+  if (!["same_day", "next_day"].includes(startCount) || !["no_roll", "next_working_day", "previous_working_day"].includes(roll)
+    || typeof includeEnd !== "boolean" || !(cutoff === null || typeof cutoff === "string")) {
+    throw new TermError("DEADLINE_POLICY_INVALID");
+  }
+  if (count < 0) throw new TermError("DEADLINE_POLICY_INVALID");
+  const monthEnd = policy.month_end === undefined ? null : policy.month_end;
+  if (CAL_UNITS.includes(unit)) {
+    if (!["last_day_of_month", "reject_nonexistent"].includes(monthEnd)) throw new TermError("DEADLINE_POLICY_INVALID");
+  } else if (monthEnd !== null && monthEnd !== "last_day_of_month" && monthEnd !== "reject_nonexistent") {
+    throw new TermError("DEADLINE_POLICY_INVALID");
+  }
+  let start = after;
+  const wants = calendarDayStep ? false : needsCalendar(unit, policy);
+  if (wants) coverage(cal as Snapshot, start);
+  if (cutoff !== null && afterTime !== null && afterTime > cutoff) {
+    start = plusDays(start, 1);
+    if (wants) coverage(cal as Snapshot, start);
+  }
+  if (startCount === "next_day") {
+    start = plusDays(start, 1);
+    if (wants) coverage(cal as Snapshot, start);
+  }
+  let due: string;
+  if (CAL_UNITS.includes(unit)) {
+    const months = count * (unit === "calendar_year" ? 12 : 1);
+    due = count > 0 ? addMonths(start, months, monthEnd) : start;
+    if (count > 0 && !includeEnd) { coverage(cal as Snapshot, due); due = previousWorking(cal as Snapshot, due); }
+  } else if (calendarDayStep || unit === "calendar_week") {
+    const multiplier = calendarDayStep ? 1 : 7;
+    due = count > 0 ? plusDays(start, multiplier * count) : start;
+    if (count > 0 && !includeEnd) { coverage(cal as Snapshot, due); due = previousWorking(cal as Snapshot, due); }
+  } else if (count > 0) {
+    due = start;
+    let counted = 0;
+    for (;;) {
+      coverage(cal as Snapshot, due);
+      if (unit === "business_day" ? working(cal as Snapshot, due) : true) {
+        counted += 1;
+        if (counted === count) break;
+      }
+      due = plusDays(due, 1);
+    }
+    if (!includeEnd) due = previousWorking(cal as Snapshot, due);
+  } else {
+    due = start;
+  }
+  const skipRoll = (calendarDayStep || [...CAL_UNITS, "calendar_week"].includes(unit)) && roll === "no_roll";
+  if (!skipRoll && !working(cal as Snapshot, due) && roll !== "no_roll") {
+    due = roll === "next_working_day" ? nextWorking(cal as Snapshot, due) : previousWorking(cal as Snapshot, due);
+  }
+  return due;
+};
+
+// §84.2 (E-0084, DECISION-0267): границы месяца — чистые функции над Date; ни
+// политика §86, ни снимок §85 не читаются (`values.month_bound_value`).
+const monthParts = (d: Val): [number, number, number] => {
+  if (!isDate(d)) throw new TermError("TYPE_ERROR");
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(d.day);
+  if (!m) throw new TermError("TYPE_ERROR");
+  const y = Number(m[1]), mo = Number(m[2]), da = Number(m[3]);
+  const last = new globalThis.Date(globalThis.Date.UTC(y, mo, 0)).getUTCDate();
+  if (mo < 1 || mo > 12 || da < 1 || da > last) throw new TermError("TYPE_ERROR");
+  return [y, mo, last];
+};
+const pad2 = (n: number): string => String(n).padStart(2, "0");
+export const month_start = (d: Val): Date => {
+  const [y, mo] = monthParts(d);
+  return { day: `${String(y).padStart(4, "0")}-${pad2(mo)}-01` };
+};
+export const month_end = (d: Val): Date => {
+  const [y, mo, last] = monthParts(d);
+  return { day: `${String(y).padStart(4, "0")}-${pad2(mo)}-${pad2(last)}` };
+};
+
+// §84.4 (E-0015): календарные дни от `a` до `b`, со знаком.
+export const days_between = (a: Date, b: Date): Dec => ({ u: BigInt(Math.round((ms(b.day) - ms(a.day)) / 86400000)), s: 0 });
+
+// §82.2: validate first; seconds are safe integers throughout years 0001–9999.
+// The fraction stays text, so no precision is lost at any length.
+const DATE_RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+const dateParts = (raw: string): globalThis.Date => {
+  if (typeof raw !== "string" || !DATE_RE.test(raw) || raw.length !== 10) throw new TermError("TYPE_ERROR");
+  const y = +raw.slice(0, 4), m = +raw.slice(5, 7), d = +raw.slice(8, 10);
+  const t = new globalThis.Date(0);
+  t.setUTCFullYear(y, m - 1, d); t.setUTCHours(0, 0, 0, 0);
+  if (y < 1 || t.getUTCFullYear() !== y || t.getUTCMonth() !== m - 1 || t.getUTCDate() !== d) throw new TermError("TYPE_ERROR");
+  return t;
+};
+const INSTANT_RE = /^([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})$/;
+const moment = (v: Instant): { seconds: number; fraction: string } => {
+  const m = typeof v.at === "string" ? INSTANT_RE.exec(v.at) : null;
+  if (m === null || m[0].length !== v.at.length) throw new TermError("TYPE_ERROR");
+  const [, day, h, mi, s, frac = "", off] = m;
+  let seconds = dateParts(day).getTime() / 1000;
+  if (+h > 23 || +mi > 59 || +s > 59) throw new TermError("TYPE_ERROR");
+  seconds += +h * 3600 + +mi * 60 + +s;
+  if (off !== "Z") {
+    const oh = +off.slice(1, 3), om = +off.slice(4, 6);
+    if (oh > 23 || om > 59) throw new TermError("TYPE_ERROR");
+    seconds -= (off[0] === "-" ? -1 : 1) * (oh * 3600 + om * 60);
+  }
+  return { seconds, fraction: frac.replace(/0+$/, "") };
+};
+const momentCmp = (a: Instant, b: Instant, op: string): number => {
+  const x = moment(a), y = moment(b);
+  return x.seconds < y.seconds ? -1 : x.seconds > y.seconds ? 1 :
+    x.fraction < y.fraction ? -1 : x.fraction > y.fraction ? 1 : 0;
+};
+export const validateTemporalCase = (kase: any): void => {
+  for (const [i, assertion] of (kase.assertions ?? []).entries()) {
+    if (!("valid" in assertion)) continue;
+    const w = assertion.valid, base = `TEMPORAL_BOUND_INVALID: request:/case/assertions/${i}/valid`;
+    if (w === null || typeof w !== "object" || Array.isArray(w)) throw new Refused(base);
+    for (const side of ["start", "end"]) {
+      if (!(side in w) || w[side] === (side === "start" ? "-infinity" : "infinity")) continue;
+      try { if (typeof w[side] === "string" && DATE_RE.test(w[side])) dateParts(w[side]); else moment({ at: w[side] }); }
+      catch (e) { if (e instanceof TermError) throw new Refused(base + "/" + side); throw e; }
+    }
+  }
+};
+// §84.1 (E-0028/E-0058): полных единиц между мгновениями, знак сохранён, дробь к нулю.
+const durationBetween = (a: Val, b: Val, unit: number, where: string): Dec => {
+  if (!isInstant(a) || !isInstant(b)) throw new TermError("TYPE_ERROR");
+  const x = moment(a), y = moment(b);
+  let seconds = y.seconds - x.seconds;
+  if (seconds > 0 && y.fraction < x.fraction) seconds -= 1;
+  else if (seconds < 0 && y.fraction > x.fraction) seconds += 1;
+  return { u: BigInt(Math.trunc(seconds / unit)), s: 0 };
+};
+export const hours_between = (a: Val, b: Val): Dec => durationBetween(a, b, 3600, "hours_between");
+export const minutes_between = (a: Val, b: Val): Dec => durationBetween(a, b, 60, "minutes_between");
+// §84.1 (E-0185): мгновение через целую Quantity секунд/минут/часов/суток; канон UTC без дробных секунд.
+const DURATION_SECONDS: Record<string, number> = { second: 1, minute: 60, hour: 3600, day: 86400 };
+export const add_duration = (after: Val, count: number, unit: string): Instant => {
+  if (!isInstant(after)) throw new TermError("TYPE_ERROR");
+  const factor = DURATION_SECONDS[unit];
+  if (factor === undefined) throw new TermError("TYPE_ERROR");
+  const x = moment(after);
+  const total = x.seconds + count * factor;
+  const d = new globalThis.Date(total * 1000);
+  if (Number.isNaN(d.getTime()) || d.getUTCFullYear() < 1 || d.getUTCFullYear() > 9999) throw new TermError("RESOURCE_LIMIT");
+  const p = (n: number): string => String(n).padStart(2, "0");
+  return { at: `${String(d.getUTCFullYear()).padStart(4, "0")}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}T${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}Z` };
+};
+
+// §84.2 (E-0029): `TermEnv.calendar_period` — снимок не читается.
+export const add_calendar_period = (after: Date, count: number, unit: string): Date => {
+  // E-0187: calendar_day validates but does not apply month_end.
+  const p = CTX.policy ?? {};
+  if (!(p.roll === undefined || p.roll === null || p.roll === "no_roll") || (p.cutoff !== undefined && p.cutoff !== null)
+    || p.include_end !== true) {
+    throw new TermError("MISSING_POLICY");
+  }
+  return { day: deadline(null, after.day, count, p, null, unit, unit === "calendar_day") };
+};
+
+const COUNTER_UNITS: Record<string, string[]> = {
+  add_business_days: ["business_day", "calendar_day"],
+  add_calendar_period: ["calendar_day", "calendar_month", "calendar_year", "calendar_week"],
+  add_legal_term: ["business_day", "calendar_day", "calendar_month", "calendar_year", "calendar_week"],
+};
+
+// §86.1 (DECISION-0256 п. 6): счётчик-связыватель — Quantity с единицей,
+// допустимой функции, целый; иначе TYPE_ERROR (`values.add_*_value`). Знак не
+// проверяется: отрицательный счётчик отвергает сама операция политикой §86.
+export const counter = (v: Val, fn: string): [number, string] => {
+  if (!isQty(v) || !COUNTER_UNITS[fn].includes(v.unit) || v.u % p10(v.s) !== 0n) throw new TermError("TYPE_ERROR");
+  return [Number(v.u / p10(v.s)), v.unit];
+};
+
+// §86.1: ветвь по единице на деле — рабочий счёт либо календарный шаг.
+export const add_legal_term = (after: Date, count: number, unit: string): Date => {
+  if (unit === "business_day" || unit === "calendar_day") return add_business_days(after, count, unit);
+  return add_calendar_period(after, count, unit);
+};
+
+// §86: `TermEnv.deadline` — политика, затем снимок, если срок его спрашивает.
+export const add_business_days = (after: Date, count: number, unit: string, afterTime?: string): Date => {
+  const POLICY = CTX.policy;
+  if (POLICY !== null && POLICY.cutoff !== undefined && POLICY.cutoff !== null && afterTime === undefined) {
+    throw new TermError("MISSING_POLICY");
+  }
+  const cal = needsCalendar(unit, POLICY) ? calendar() : null;
+  return { day: deadline(cal, after.day, count, POLICY, afterTime === undefined ? null : afterTime, unit) };
+};
+
+// ---------------------------------------------------------------------------
+// §47.3 Канал суждения (DECISION-0274): порт `whynot.judgment_blockers`,
+// `defeater_judgment_blockers`, `power_judgment_blockers` и
+// `position_judgment_blockers` над ГОТОВЫМ состоянием модели. Один код для
+// раннера и API: модель и переводы термов приходят параметрами. Запрос
+// называет судью только там, где его ответ может изменить исход: живость
+// правила по конъюнктам (E-0101), по поражению вывода (E-0103), по способности
+// дефитера снять вывод (E-0100), по иммунитету (E-0120); порядок запросов —
+// канонические байты объекта `request` (E-0111).
+export type JHooks = {
+  val: (term: any) => Val;                          // литерал-терм §53 → значение
+  cell: (pred: string, col: number, v: Val) => any; // ячейка таблицы → литерал-терм
+};
+export const JUDGMENT_ENUM_CAP = 8;
+const JUDGMENT_TESTABLE = new Set(["established", "supported", "monotone", "refuted"]);
+const JMIRROR: Record<string, string> = { TRUE_ONLY: "FALSE_ONLY", FALSE_ONLY: "TRUE_ONLY", BOTH: "BOTH", NEITHER: "NEITHER" };
+const CONJUNCT_STATUS: Record<string, string> = { TRUE_ONLY: "SATISFIED", FALSE_ONLY: "NOT_SATISFIED", BOTH: "CONFLICTED", NEITHER: "UNDETERMINED" };
+const JCOMPUTED = new Set(["binary", "call", "if", "let", "match", "aggregate"]);
+
+// Канонические байты §208 объекта запроса: ключи по порядку, строки как JSON,
+// целое из JSON — цифрами; порядок строк — по кодам символов (UTF-8 у оракула).
+export const jcanon = (v: any): string => {
+  if (v === null || v === undefined) return "null";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "string") return JSON.stringify(v);
+  if (typeof v === "number") return String(v);
+  if (Array.isArray(v)) return "[" + v.map(jcanon).join(",") + "]";
+  if (typeof v === "object" && "int" in v && Object.keys(v).length === 1) return String(v.int);
+  return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + jcanon(v[k])).join(",") + "}";
+};
+export const requestKey = (lit: any): string =>
+  jcanon({ relation: lit.predicate, polarity: lit.polarity ?? "positive", args: lit.args ?? [] });
+export const orderRequests = (lits: any[]): any[] => {
+  const found = new Map<string, any>();
+  for (const l of lits) { const k = requestKey(l); if (!found.has(k)) found.set(k, l); }
+  return [...found.keys()].sort().map((k) => found.get(k));
+};
+
+const jtruth = (M: any, hooks: JHooks, lit: any): string => {
+  const st: string = M.status(lit.predicate, (lit.args ?? []).map(hooks.val));
+  return (lit.polarity ?? "positive") === "negative" ? JMIRROR[st] : st;
+};
+const jvars = (t: any, out: Set<string>): void => {
+  if (Array.isArray(t)) { for (const x of t) jvars(x, out); return; }
+  if (t === null || typeof t !== "object") return;
+  if (t.kind === "var") { out.add(String(t.var)); return; }
+  for (const k of Object.keys(t)) jvars(t[k], out);
+};
+const jkind = (name: string): string => {
+  if (name === "urn:law:std#Integer" || name === "urn:law:std#Natural") return "i";
+  if (name === "urn:law:std#Decimal") return "d";
+  if (name === "urn:law:std#Money") return "m";
+  if (name === "urn:law:std#Rational") return "r";
+  if (name === "urn:law:std#Quantity") return "q";
+  return "x";
+};
+// Гард §57–§58 под подстановкой: переменные, литералы, константы §54 и
+// арифметика §58; иное — исключение, у оракула это UNDETERMINED (E-0101).
+const jterm = (M: any, hooks: JHooks, t: any, subst: Record<string, any>): { v: Val; k: string } => {
+  if (t.kind === "var") {
+    if (!(t.var in subst)) throw new Refused("несвязанная переменная гарда");
+    return jterm(M, hooks, subst[t.var], subst);
+  }
+  if (t.kind === "const_ref" && M.BACKCHAIN_CONSTS && t.id in M.BACKCHAIN_CONSTS) return jterm(M, hooks, M.BACKCHAIN_CONSTS[t.id], subst);
+  if (t.kind === "value") return { v: hooks.val(t), k: jkind(String(t.type?.name)) };
+  if (t.kind === "entity_ref" || t.kind === "const_ref") return { v: hooks.val(t), k: "x" };
+  if (t.kind === "binary" && ["add", "sub", "mul", "div", "mod"].includes(String(t.op))) {
+    const l = jterm(M, hooks, t.left, subst), r = jterm(M, hooks, t.right, subst);
+    if (l.k === "x" || r.k === "x") throw new Refused("арифметика над нечисловым операндом");
+    const v = arith(String(t.op), l.v, r.v, l.k, r.k);
+    const k = v instanceof Rat ? "r" : isMoney(v) ? "m" : isQty(v) ? "q" : l.k === "i" && r.k === "i" ? "i" : "d";
+    return { v, k };
+  }
+  throw new Refused("терм гарда вне обхода суждения: " + String(t.kind));
+};
+const jguard = (M: any, hooks: JHooks, g: any, subst: Record<string, any>): boolean => {
+  const l = jterm(M, hooks, g.left, subst), r = jterm(M, hooks, g.right, subst);
+  return cmp(l.v, String(g.op), r.v);
+};
+
+type JReport = { trigger: string; ground: any } | null;
+// Порт `whynot._conjunct_report`: null — конъюнкт с несвязанной переменной.
+const jconjunct = (M: any, hooks: JHooks, status: string, lit: any, subst: Record<string, any>): JReport => {
+  if (status === "guard") {
+    const vars = new Set<string>(); jvars(lit, vars);
+    if ([...vars].some((v) => !(v in subst))) return null;
+    let ok: boolean;
+    try { ok = jguard(M, hooks, lit, subst); } catch (e) { return { trigger: "UNDETERMINED", ground: null }; }
+    return { trigger: ok ? "SATISFIED" : "NOT_SATISFIED", ground: null };
+  }
+  if (lit?.kind !== "literal") return { trigger: "UNDETERMINED", ground: null };
+  const args: any[] = lit.args ?? [];
+  const vars = new Set<string>(); jvars(args, vars);
+  if ([...vars].some((v) => !(v in subst))) return null;
+  if (args.some((a) => JCOMPUTED.has(a?.kind))) return { trigger: "UNDETERMINED", ground: null };
+  const shown = { ...lit, args: args.map((a) => (a.kind === "var" ? subst[a.var] : a)) };
+  if (args.some((a) => a?.kind === "wildcard")) {
+    // §98 (E-0165): свидетель существования, значение не связывается.
+    if ((lit.polarity ?? "positive") !== "positive" || !["established", "supported", "monotone"].includes(status)) {
+      return { trigger: "UNDETERMINED", ground: shown };
+    }
+    const rows: Val[][] = M.TABLES[lit.predicate] ?? [];
+    const want = shown.args.map((a: any) => (a.kind === "wildcard" ? null : hooks.val(a)));
+    const witness = rows.some((row) => row.length === want.length && row.every((v, i) => want[i] === null || key([v]) === key([want[i] as Val]))
+      && (status === "established" ? M.status(lit.predicate, row) === "TRUE_ONLY" : ["TRUE_ONLY", "BOTH"].includes(M.status(lit.predicate, row))));
+    return { trigger: witness ? "SATISFIED" : "UNDETERMINED", ground: shown };
+  }
+  const pair = jtruth(M, hooks, shown);
+  if (status === "not_known") return { trigger: pair === "NEITHER" ? "SATISFIED" : "NOT_SATISFIED", ground: shown };
+  if (status === "supported" || status === "monotone") {
+    return { trigger: pair === "TRUE_ONLY" || pair === "BOTH" ? "SATISFIED" : "UNDETERMINED", ground: shown };
+  }
+  if (status === "refuted" || status === "unknown") {
+    const want = status === "refuted" ? "FALSE_ONLY" : "NEITHER";
+    return { trigger: pair === want ? "SATISFIED" : "NOT_SATISFIED", ground: shown };
+  }
+  return { trigger: CONJUNCT_STATUS[pair] ?? "UNDETERMINED", ground: shown };
+};
+
+// Порт `unify_head`: подстановка головы под ground-цель; переменная дважды — одинаково.
+const junify = (head: any, target: any): Record<string, any> | null => {
+  if (head?.kind !== "literal" || target?.kind !== "literal") return null;
+  if (head.predicate !== target.predicate) return null;
+  if ((head.polarity ?? "positive") !== (target.polarity ?? "positive")) return null;
+  const h: any[] = head.args ?? [], g: any[] = target.args ?? [];
+  if (h.length !== g.length) return null;
+  const subst: Record<string, any> = {};
+  for (let i = 0; i < h.length; i++) {
+    if (h[i].kind === "var") {
+      if (h[i].var in subst && jcanon(subst[h[i].var]) !== jcanon(g[i])) return null;
+      subst[h[i].var] = g[i];
+    } else if (jcanon(h[i]) !== jcanon(g[i])) return null;
+  }
+  return subst;
+};
+
+// DECISION-0036 (б): перечисление судейского конъюнкта по активному домену —
+// аргументы всех атомов таблиц, порядок §208, кап ДО фильтра по NEITHER.
+const jenumerate = (M: any, hooks: JHooks, lit: any, subst: Record<string, any>, unbound: string[]): any[] => {
+  const args: any[] = lit.args ?? [];
+  if (args.some((a) => a?.kind === "wildcard")) return [];
+  const domain = new Map<string, any>();
+  for (const pred of Object.keys(M.TABLES)) {
+    for (const row of M.TABLES[pred] as Val[][]) {
+      row.forEach((v, i) => { const t = hooks.cell(pred, i, v); domain.set(jcanon(t), t); });
+    }
+  }
+  const terms = [...domain.keys()].sort().map((k) => domain.get(k));
+  if (terms.length === 0) return [];
+  const names = [...unbound].sort();
+  const out: any[] = [];
+  let n = 0;
+  const total = Math.pow(terms.length, names.length);
+  for (let idx = 0; idx < total && n < JUDGMENT_ENUM_CAP; idx++, n++) {
+    // itertools.product: первая переменная меняется медленнее всех.
+    const full: Record<string, any> = { ...subst };
+    let rest = idx;
+    for (let j = names.length - 1; j >= 0; j--) { full[names[j]] = terms[rest % terms.length]; rest = Math.floor(rest / terms.length); }
+    const ground = { ...lit, args: args.map((a) => (a.kind === "var" ? full[a.var] : a)) };
+    if (jtruth(M, hooks, ground) === "NEITHER") out.push(ground);
+  }
+  return out;
+};
+
+const jprio = (M: any): Set<string> => (M.PRIO_ACTIVE ?? M.PRIO ?? new Set<string>());
+const jrowKey = (hooks: JHooks, lit: any): string => key((lit.args ?? []).map(hooks.val));
+
+// E-0103: поражён ли был бы вывод поражаемого правила при любом ответе судьи —
+// дефитер цели уже дал применение, и правило не старше его по §106.
+const jconclusionDefeated = (M: any, hooks: JHooks, rule: any, target: any): boolean => {
+  if (rule.strength !== "defeasible") return false;
+  const prio = jprio(M), tkey = jrowKey(hooks, target), pos = (target.polarity ?? "positive") !== "negative";
+  for (const a of (M.APPLIED ?? []) as any[]) {
+    if (!a.defeater || a.urn !== target.predicate || a.key !== tkey || a.positive !== pos) continue;
+    if (!prio.has(rule.name + ">" + a.rule)) return true;
+  }
+  return false;
+};
+// E-0100: способен ли живой дефитер снять СТОЯЩИЙ вывод — строгая опора не
+// поражается; каждое уцелевшее поражаемое применение обязано уступать ему.
+const jdefeaterCanRemove = (M: any, hooks: JHooks, rule: any, target: any): boolean => {
+  const row = (target.args ?? []).map(hooks.val);
+  const bits: number = typeof M.supportBits === "function" ? M.supportBits(target.predicate, row) : 0;
+  const pos = (target.polarity ?? "positive") !== "negative";
+  if ((bits & (pos ? 1 : 2)) !== 0) return false;
+  const tkey = key(row), prio = jprio(M);
+  const apps = ((M.APPLIED ?? []) as any[]).filter((a) => !a.defeater && !a.defeated && a.urn === target.predicate && a.key === tkey && a.positive === pos);
+  if (apps.length === 0) return false;
+  for (const a of apps) if (prio.has(a.rule + ">" + rule.name)) return false;
+  return true;
+};
+
+// Порт `whynot._collect_judgments`: общий обход §185 от цели без опоры
+// (rootDefeaters=false) и от стоящей цели через дефитеры её головы (true).
+export const collectJudgments = (M: any, hooks: JHooks, goal: any, rootDefeaters: boolean): any[] => {
+  const J: Record<string, any> = M.JUDGMENTS ?? {};
+  const index = new Map<string, any[]>();
+  for (const r of (M.BACKCHAIN ?? []) as any[]) index.set(r.head.predicate, [...(index.get(r.head.predicate) ?? []), r]);
+  const found = new Map<string, any>(), visited = new Set<string>();
+  const now = legalTime();
+  const dead = (reports: [string, any, JReport][]): boolean => {
+    for (const [st, , rep] of reports) {
+      if (rep === null || (rep.trigger !== "NOT_SATISFIED" && rep.trigger !== "CONFLICTED")) continue;
+      // DECISION-0036 (а): refuted-тест над самим отношением суждения при паре NEITHER решает судья.
+      if (st === "refuted" && rep.ground !== null && rep.ground.predicate in J && jtruth(M, hooks, rep.ground) === "NEITHER") continue;
+      return true;
+    }
+    return false;
+  };
+  const walk = (target: any, defeatersOnly: boolean): void => {
+    const vkey = jcanon({ p: target.predicate, a: target.args ?? [], n: target.polarity ?? "positive" });
+    if (visited.has(vkey)) return;
+    visited.add(vkey);
+    for (const r of index.get(target.predicate) ?? []) {
+      if (defeatersOnly && r.strength !== "defeater") continue;
+      const subst = junify(r.head, target);
+      if (subst === null) continue;
+      const w = r.window;
+      if (w && ((w.start && now < w.start) || (w.end && now >= w.end))) continue;
+      const reports: [string, any, JReport][] = (r.body as [string, any][]).map(([st, lit]) => [st, lit, jconjunct(M, hooks, st, lit, subst)]);
+      if (dead(reports)) continue;
+      if (jconclusionDefeated(M, hooks, r, target)) continue;
+      if (defeatersOnly && !jdefeaterCanRemove(M, hooks, r, target)) continue;
+      for (const [st, lit, rep] of reports) {
+        if (rep === null) {
+          if (JUDGMENT_TESTABLE.has(st) && lit?.kind === "literal" && lit.predicate in J) {
+            const vars = new Set<string>(); jvars(lit.args ?? [], vars);
+            const unbound = [...vars].filter((v) => !(v in subst));
+            for (const g of jenumerate(M, hooks, lit, subst, unbound)) { const k = requestKey(g); if (!found.has(k)) found.set(k, g); }
+          }
+          continue;
+        }
+        const ground = rep.ground;
+        if (ground === null || ground.kind !== "literal" || (ground.args ?? []).some((a: any) => a?.kind === "wildcard")) continue;
+        if (rep.trigger === "UNDETERMINED") {
+          if (ground.predicate in J) { const k = requestKey(ground); if (!found.has(k)) found.set(k, ground); }
+          else walk(ground, false);
+        } else if (st === "refuted" && rep.trigger === "NOT_SATISFIED" && ground.predicate in J && jtruth(M, hooks, ground) === "NEITHER") {
+          const k = requestKey(ground); if (!found.has(k)) found.set(k, ground);
+        }
+      }
+    }
+  };
+  walk(goal, rootDefeaters);
+  return [...found.values()];
+};
+
+const nlitToLiteral = (hooks: JHooks, n: any): any =>
+  ({ kind: "literal", polarity: n.positive ? "positive" : "negative", predicate: n.pred, args: (n.row as Val[]).map((v, i) => hooks.cell(n.pred, i, v)) });
+const nlitStatus = (M: any, n: any): string => { const st: string = M.status(n.pred, n.row); return n.positive ? st : JMIRROR[st]; };
+
+// E-0100, носитель `valid_when` §127: судьи действительности осуществлённого
+// полномочия, чей эффект есть цель; E-0120 — не при эффекте, запертом иммунитетом.
+export const powerJudgments = (M: any, hooks: JHooks, goal: any): any[] => {
+  const J: Record<string, any> = M.JUDGMENTS ?? {};
+  if ((goal.polarity ?? "positive") !== "positive" || !M.POSITIONS) return [];
+  const gkey = goal.predicate + "" + jrowKey(hooks, goal);
+  if (M.BLOCKED_IMMUNITY && M.BLOCKED_IMMUNITY.has(gkey)) return [];
+  const out: any[] = [];
+  for (const p of M.POSITIONS as any[]) {
+    if (p.modality !== "power" || p.status !== "ACTIVE") continue;
+    const eff = p.spec.effect;
+    if (!eff || !eff.positive || eff.pred !== goal.predicate || key(eff.row) !== jrowKey(hooks, goal)) continue;
+    if (!p.spec.exercise || !["TRUE_ONLY", "BOTH"].includes(nlitStatus(M, p.spec.exercise))) continue;
+    const vw = p.spec.validWhen;
+    if (!vw || !(vw.pred in J)) continue;
+    if (nlitStatus(M, vw) === "NEITHER") out.push(nlitToLiteral(hooks, vw));
+  }
+  return orderRequests(out);
+};
+// E-0100, носитель `condition` цели §123/§124: судьи статуса позиции обязанности.
+export const positionJudgments = (M: any, hooks: JHooks): any[] => {
+  const J: Record<string, any> = M.JUDGMENTS ?? {};
+  if (!M.POSITIONS) return [];
+  const out: any[] = [];
+  for (const p of M.POSITIONS as any[]) {
+    if (p.status !== "ACTIVE" && p.status !== "UNDETERMINED") continue;
+    const cond = p.spec.cond;
+    if (!cond || !(cond.pred in J)) continue;
+    if (nlitStatus(M, cond) === "NEITHER") out.push(nlitToLiteral(hooks, cond));
+  }
+  return orderRequests(out);
+};
+
+// JudgmentRequest схемы evaluation по упорядоченным блокерам (без proof-узла).
+export const buildRequests = (M: any, blockers: any[], tail: string): any[] =>
+  blockers.map((b, i) => {
+    const d = M.JUDGMENTS[b.predicate] ?? {};
+    const r: any = { id: `urn:judgment:${tail}:${i}`, predicate: b.predicate, authority: d.authority ?? b.predicate,
+                     request: { relation: b.predicate, polarity: b.polarity ?? "positive", args: b.args ?? [] } };
+    if (d.requestSchema !== undefined) r.requestSchema = d.requestSchema;
+    return r;
+  });
+
+// Порт ветвей `queries.query_truth`: цель — отношение суждения без опоры;
+// цель без опоры — тела правил и `valid_when`; стоящая цель — дефитеры головы.
+export const judgmentBlockers = (M: any, hooks: JHooks, goal: any, status: string, conflict: boolean): any[] => {
+  const J: Record<string, any> = M.JUDGMENTS ?? {};
+  if (Object.keys(J).length === 0) return [];
+  const unresolved = status === "NEITHER" && !conflict;
+  if (goal.predicate in J && unresolved) return [goal];
+  if (unresolved) return orderRequests([...collectJudgments(M, hooks, goal, false), ...powerJudgments(M, hooks, goal)]);
+  if (status === "TRUE_ONLY" && !conflict) return orderRequests(collectJudgments(M, hooks, goal, true));
+  return [];
+};
+
+// §47.3.1 (E-0089): ответ судьи с объектом `judgment` — орган и форма payload.
+// Возвращает код issue либо null (ответ принят).
+const JKINDS: Record<string, string> = {
+  "urn:law:std#Boolean": "boolean", "urn:law:std#Decimal": "decimal", "urn:law:std#Text": "text", "urn:law:std#Date": "date",
+  "urn:law:std#Instant": "instant", "urn:law:std#Integer": "integer", "urn:law:std#Natural": "integer",
+  "urn:law:std#Money": "money", "urn:law:std#Quantity": "quantity", "urn:law:std#Rational": "rational",
+};
+export const judgmentAnswer = (M: any, assertion: any): string | null => {
+  const judgment = assertion.judgment;
+  if (judgment === null || typeof judgment !== "object") return null;
+  const pred = assertion.literal?.predicate;
+  const d = (M.JUDGMENTS ?? {})[pred] ?? {};
+  if (judgment.authority !== (d.authority ?? pred)) return "JUDGMENT_AUTHORITY_MISMATCH";
+  const payload = judgment.payload;
+  if (payload !== undefined && payload !== null) {
+    const schema = d.requestSchema;
+    if (schema === undefined || schema === null) return "JUDGMENT_PAYLOAD_MISMATCH";
+    const want = JKINDS[String(schema.name)];
+    if (want !== undefined) {
+      const got = payload.kind === "value" ? JKINDS[String(payload.type?.name)] : payload.kind === "entity_ref" ? "entity_ref" : "enum";
+      if (got !== want) return "JUDGMENT_PAYLOAD_MISMATCH";
+    }
+  }
+  return null;
+};
+
+export const admitNumericInputs = (kase: any, query: any, judgments = false): void => {
+  const stack = [query, ...(kase.assertions ?? []).map((a: any) => a.literal ?? {})];
+  while (stack.length) {
+    const n = stack.pop();
+    if (Array.isArray(n)) stack.push(...n);
+    else if (n !== null && typeof n === "object") {
+      if (n.kind === "value" && n.type?.name === "urn:law:std#Number") throw new Refused("NUMBER_UNAVAILABLE: exact Number and slot narrowing (E-0316/E-0319/E-0334) are outside this slice");
+      if (judgments && ["aggregate", "comprehension"].includes(n.kind)) throw new Refused("AGGREGATE_JUDGMENT_UNAVAILABLE: open aggregate members require E-0357");
+      stack.push(...Object.values(n).filter(v => v !== null && typeof v === "object"));
+    }
+  }
+};