arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/ts/evaluate.ts

@@ -0,0 +1,894 @@
+// Единый вычислительный вход TypeScript-цели (DECISION-0423 §2.2).
+//
+// Дело и вопрос приходят в канонической форме (§168, §172) — той же, что у
+// векторов и оракула, — и `evaluate` возвращает ответ исполняемого профиля.
+// Раннер и API вызывают только его, поэтому сверка аргументов §189, разворот
+// контекста, насыщение и лестница статусов §175 у них одни. Состояние — на вызов
+// (§2.3): модель строит `newModel()`, контекст рантайма ставится на время вызова,
+// сопутствующие множества живут в замыкании. Ответ — БЕЗ доказательства и
+// хэшей: профиль core-executable. Целые в значениях — носитель `{int: "цифры"}`.
+import * as RT from "./runtime";
+import { Val } from "./runtime";
+import { newModel } from "./model";
+
+export type EvaluateOptions = { stats?: Record<string, number>; api?: boolean };
+
+// Канонические байты §208 значения: ключи по порядку, без пробелов, целое — цифрами.
+export const canonJson = (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 (typeof v === "bigint") return v.toString();
+  if (Array.isArray(v)) return "[" + v.map(canonJson).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) + ":" + canonJson(v[k])).join(",") + "}";
+};
+
+// Порядок байтов UTF-8 строк без Buffer: для корректного Unicode он совпадает с
+// порядком кодовых точек, поэтому модуль не зависит от Node (DECISION-0423 §2.7).
+export const cmpUtf8 = (a: string, b: string): number => {
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    const x = a.codePointAt(i) as number;
+    const y = b.codePointAt(j) as number;
+    if (x !== y) return x < y ? -1 : 1;
+    i += x > 0xffff ? 2 : 1;
+    j += y > 0xffff ? 2 : 1;
+  }
+  const restA = i < a.length;
+  const restB = j < b.length;
+  return restA === restB ? 0 : restA ? 1 : -1;
+};
+
+// Ответ на вопрос `query` по делу `kase`. Названный отказ среза — `RT.Refused`;
+// ошибка значения вне вопроса `term` и вне правил модели становится тем же отказом.
+export const evaluate = (kase: any, query: any, opts: EvaluateOptions = {}): any => {
+  if (query?.kind === "positions")
+    throw new RT.Refused("POSITIONS_UNAVAILABLE: positions requires current norm ranks (W6)");
+  RT.validateTemporalCase(kase);
+  const prev = RT.beginContext();
+  try {
+    return evaluateIn(kase, query, opts);
+  } catch (e) {
+    if (e instanceof RT.TermError) throw new RT.Refused("ошибка значения вне среза раннера: " + e.code);
+    throw e;
+  } finally {
+    RT.endContext(prev);
+  }
+};
+
+const evaluateIn = (kase: any, query: any, opts: EvaluateOptions): any => {
+  const M = newModel();
+  for (const assertion of kase.assertions ?? [])
+    if (M.NODE_IDS.includes(assertion.id)) throw new RT.Refused("LDC-E1382: case assertion id collides with a program node");
+  RT.admitNumericInputs(kase, query, Object.keys(M.JUDGMENTS).length > 0);
+
+  const ISSUES: string[] = [];
+  const TYPE_ERROR_PREDICATES = new Set<string>();
+  // Запись строки, поданная делом как сущность и как Text, — в рантайме одно
+  // значение, у оракула — разные атомы. Для печати результата вид берётся по
+  // тому, как запись подана; одна запись в обеих ролях — названный отказ.
+  const ENTITIES = new Set<string>();
+  const TEXTS = new Set<string>();
+
+  const arg = (a: any): Val => {
+    if (a.kind === "entity_ref") { ENTITIES.add(a.id as string); return a.id as string; }
+    if (a.kind === "const_ref") {
+      // §54: разыменование предшествует исполнению; ниже ссылок нет.
+      const c = M.CONSTS[a.id];
+      // Член перечисления §38 либо имя без объявления: оракул оставляет такой
+      // const_ref в ключе атома как есть — значение есть идентичность.
+      if (c === undefined) return RT.sym(String(a.id));
+      return c[1];
+    }
+    if (a.kind !== "value") throw new RT.Refused("аргумент вне среза раннера: " + String(a.kind));
+    const t = a.type?.name;
+    // §208/§48 (errata E-0197, E-0202, E-0203): сырое поле литерала читается по
+    // грамматике §208, а не `String()`/`Number()` цели. `String(a.value)` давал
+    // литералу без `value` значение "undefined", а целое i64 приходило из
+    // JSON.parse уже потерявшим знаки.
+    const raw = a.value;
+    if (t === "urn:law:std#Money") return RT.litMoney(raw, a.currency);
+    if (t === "urn:law:std#Decimal") return RT.litDec(raw);
+    if (t === "urn:law:std#Integer") return RT.litInt(raw);
+    if (t === "urn:law:std#Text") { const s = RT.litText(raw); TEXTS.add(s); return s; }
+    if (t === "urn:law:std#Date") return RT.date(RT.litText(raw));
+    if (t === "urn:law:std#Instant") return RT.instant(RT.litText(raw));
+    // §168.1 (DECISION-0252 п. 8): только каноническая запись, иная — отказ.
+    if (t === "urn:law:std#Rational") return RT.rat(raw);
+    // §49 v1 (DECISION-0256 п. 7): значение и тег единицы как записаны.
+    if (t === "urn:law:std#Quantity" && a.unit) return RT.litQty(raw, a.unit);
+    if (t === "urn:law:std#Boolean") {
+      // DECISION-0266: только JSON-булево; иная запись у оракула — TYPE_ERROR при чтении значения.
+      if (typeof raw !== "boolean") throw new RT.Refused("значение Boolean не true/false вне среза раннера (§48)");
+      return raw;
+    }
+    if (t === "urn:law:std#Natural") {
+      // DECISION-0266: неотрицательное целое; иное у оракула — TYPE_ERROR при чтении значения.
+      const [k, text] = RT.rawLit(raw);
+      if (k !== "i" || text.startsWith("-")) throw new RT.Refused("значение Natural не неотрицательное целое вне среза раннера (§48)");
+      return RT.litInt(raw);
+    }
+    throw new RT.Refused("аргумент вне среза раннера: " + String(t));
+  };
+
+  // Тип аргумента, если известен: у value — из узла, у const_ref — из
+  // объявления константы; entity_ref типа не несёт (как у оракула).
+  const argType = (a: any): string | undefined => {
+    if (a.kind === "value") return a.type?.name;
+    // Оракул разыменовывает константы §54 до сверки: сущность и член
+    // перечисления типа не несут, тип — только у константы std-типа.
+    if (a.kind === "const_ref") {
+      const t = M.CONSTS[a.id]?.[0];
+      return t !== undefined && t.startsWith("urn:law:std#") ? t : undefined;
+    }
+    return undefined;
+  };
+
+  // Совпадение типа с наследованием сущностей вверх от фактического.
+  const conforms = (actual: string, expected: string): boolean => {
+    const seen = new Set<string>();
+    let cur: string | undefined = actual;
+    while (cur !== undefined && !seen.has(cur)) {
+      if (cur === expected) return true;
+      seen.add(cur);
+      cur = M.BASES[cur];
+    }
+    return false;
+  };
+
+  // Арность и типы аргументов утверждения против сигнатуры §189 (E-0046) —
+  // зеркало check_argument_types оракула: несогласованное утверждение не
+  // принимается, причина названа кодом TYPE_ERROR; entity_ref типа не несёт;
+  // предикат без сигнатуры принимается (его никто не читает). Проверка идёт
+  // ДО преобразования значений.
+  const wellTyped = (lit: any): boolean => {
+    const params = M.PARAMS[lit.predicate];
+    if (params === undefined) return true;
+    const args: any[] = lit.args ?? [];
+    if (args.length !== params.length) { ISSUES.push("TYPE_ERROR"); TYPE_ERROR_PREDICATES.add(lit.predicate); return false; }
+    for (let i = 0; i < args.length; i++) {
+      const actual = argType(args[i]);
+      if (actual !== undefined && !conforms(actual, params[i])) { ISSUES.push("TYPE_ERROR"); TYPE_ERROR_PREDICATES.add(lit.predicate); return false; }
+    }
+    return true;
+  };
+
+  const queryTyped = (lit: any): boolean => {
+    const params = M.PARAMS[lit.predicate];
+    if (params === undefined) return false;
+    const args: any[] = lit.args ?? [];
+    if (args.length !== params.length) return false;
+    return args.every((a, i) => argType(a) === undefined || conforms(argType(a) as string, params[i]));
+  };
+
+  // --- вопросы term §57–§59 и collect §52.1 -------------------------------------
+  // Срез раннера: comprehension по установленным атомам таблиц с гардами,
+  // элемент — ячейка или литерал; агрегаты count/sum/min/max; арифметика §58
+  // и функции рантайма над результатом. Вид результата выводится статически
+  // по тем же таблицам §58, что у плана: у оракула вид — часть значения
+  // (Integer 5 и Decimal 5 — разные байты), у рантайма — нет.
+  const INT = "urn:law:std#Integer", DEC = "urn:law:std#Decimal", MON = "urn:law:std#Money";
+  const TEXT = "urn:law:std#Text", DATE = "urn:law:std#Date", RAT = "urn:law:std#Rational";
+  const INSTANT = "urn:law:std#Instant";
+  const QTY = "urn:law:std#Quantity", BOOL = "urn:law:std#Boolean", NAT = "urn:law:std#Natural";
+  const CMP_OPS = ["lt", "le", "gt", "ge", "eq", "ne"];
+  type Typed = { v: Val; t: string };            // t — URN типа std либо "entity" | "enum"
+  type Env = Record<string, Typed>;
+
+  const isNumT = (t: string): boolean => t === INT || t === DEC || t === MON || t === RAT || t === QTY || t === NAT;
+  // DECISION-0252 п. 3: вид операнда для `arith` рантайма. У вопроса вид каждого
+  // значения известен точно — из литерала, слота или исхода операции.
+  const KIND_CODE: Record<string, string> = { [INT]: "i", [DEC]: "d", [MON]: "m", [RAT]: "r", [QTY]: "q", [NAT]: "i" };
+  // DECISION-0266: Natural считает как Integer (`values._TYPE_KINDS`), тип-строка при этом своя.
+  const norm = (t: string): string => (t === NAT ? INT : t);
+  // §59 (errata E-0195): вид элемента ПУСТОЙ коллекции несёт ОБЪЯВЛЕННЫЙ тип
+  // проекции comprehension §52.1 (`variable.type.name`) — единственный носитель
+  // вида, не зависящий от числа решений generator-а (порт
+  // `values.aggregate_element_type`). Таблица — порт `values._TYPE_KINDS` плюс
+  // `_OPAQUE_KINDS`: Natural и Integer у оракула один вид `integer`. Имя вне
+  // таблицы (сущность, перечисление, чужой символ) вида не предъявляет, и сверка
+  // МОЛЧИТ: Unknown есть «утверждать нечего», а не «совместимо со всем».
+  const EMPTY_ELEMENT_KINDS: Record<string, string> = {
+    [INT]: INT, [NAT]: INT, [DEC]: DEC, [MON]: MON, [TEXT]: TEXT, [DATE]: DATE,
+    [BOOL]: BOOL, [RAT]: RAT, [QTY]: QTY,
+    "urn:law:std#Instant": "urn:law:std#Instant",
+    "urn:law:std#Magnitude": "urn:law:std#Magnitude",
+    "urn:law:std#Bounds": "urn:law:std#Bounds",
+  };
+
+  const arithKind = (op: string, l: string, r: string): string => {
+    l = norm(l); r = norm(r);
+    if (!isNumT(l) || !isNumT(r)) throw new RT.Refused("арифметика вне среза (§58): не числовой операнд " + op);
+    if (op === "add" || op === "sub") {
+      if (l !== r) throw new RT.Refused("арифметика вне среза (§58): виды операндов не совпадают у " + op);
+      return l;
+    }
+    if (op === "mul") {
+      if (l === MON && r === MON) throw new RT.Refused("арифметика вне среза (§58): произведение двух размерных величин не определено");
+      if (l === INT || r === INT) return l === INT ? r : l;
+      return l === MON || r === MON ? MON : DEC;
+    }
+    if (op === "div") {
+      if ((l === DEC && r === DEC) || (l === MON && r === MON)) return DEC;
+      if (l === MON && r === DEC) return MON;
+      if (l === INT && r === INT) throw new RT.Refused("арифметика вне среза (§58): частное Integer/Integer — Rational");
+      throw new RT.Refused("арифметика вне среза (§58): пара вне таблицы делимых");
+    }
+    if (op === "mod") {
+      if (l !== INT || r !== INT) throw new RT.Refused("арифметика вне среза (§58): остаток только Integer mod Integer");
+      return INT;
+    }
+    throw new RT.Refused("операция вне среза раннера: " + op);
+  };
+
+  const callKind = (fn: string, ks: string[]): string => {
+    if (fn === "min" || fn === "max") {
+      if (ks.length !== 2 || !isNumT(ks[0]) || ks[0] !== ks[1]) throw new RT.Refused("арифметика вне среза (§58): виды операндов не совпадают у " + fn);
+      return ks[0];
+    }
+    if (fn === "abs") {
+      if (ks.length !== 1 || !isNumT(ks[0])) throw new RT.Refused("арифметика вне среза (§58): abs над нечисловым видом");
+      return ks[0];
+    }
+    if (fn === "pow") {
+      if (ks.length !== 2 || ks[0] !== INT || ks[1] !== INT) throw new RT.Refused("арифметика вне среза (§58): pow только Integer pow Integer");
+      return INT;
+    }
+    if (fn === "round") {
+      if (ks.length !== 3) throw new RT.Refused("round вне среза раннера: ожидаются значение, разряды и режим (§50)");
+      if (ks[0] === RAT) throw new RT.Refused("round над Rational вне среза генератора (§50: round не берёт Rational)");
+      if (!isNumT(ks[0])) throw new RT.Refused("round вне среза генератора: вид операнда не числовой (§50)");
+      policyKinds("round", ks.slice(1));
+      return ks[0];
+    }
+    if (fn === "div_round") {
+      // §50/§58 (E-0036, E-0170; DECISION-0259 п. 3): четыре пары видов.
+      if (ks.length !== 4) throw new RT.Refused("div_round вне среза генератора: ожидаются делимое, делитель, точность и режим (§50)");
+      if (ks[0] === RAT || ks[1] === RAT) throw new RT.Refused("div_round над Rational вне среза генератора (§50/§58, E-0036)");
+      const pairIs = (x: string, y: string): boolean => ks[0] === x && ks[1] === y;
+      if (!(pairIs(MON, DEC) || pairIs(QTY, DEC) || pairIs(DEC, DEC) || pairIs(MON, MON))) {
+        throw new RT.Refused("div_round вне среза генератора: пара видов вне E-0036/E-0170 (§50/§58)");
+      }
+      policyKinds("div_round", ks.slice(2));
+      return pairIs(MON, DEC) ? MON : pairIs(QTY, DEC) ? QTY : DEC;
+    }
+    if (fn === "month_start_of" || fn === "month_end_of") {
+      // §84.2 (E-0084, DECISION-0267): арность и вид — TYPE_ERROR оракула (`month_bound_value`).
+      if (ks.length !== 1 || ks[0] !== DATE) throw new RT.TermError("TYPE_ERROR");
+      return DATE;
+    }
+    if (fn === "hours_between" || fn === "minutes_between") {
+      // §84.1 (E-0028/E-0058; W2 часть 2): оба аргумента — Instant, иначе TYPE_ERROR оракула.
+      if (ks.length !== 2 || ks[0] !== INSTANT || ks[1] !== INSTANT) throw new RT.TermError("TYPE_ERROR");
+      return INT;
+    }
+    if (fn === "add_duration") throw new RT.Refused("add_duration в вопросе вне среза раннера (§84.1)");
+    throw new RT.Refused("функция вне среза раннера: " + fn);
+  };
+  // Имя функции рантайма по имени std-функции вопроса.
+  const RT_NAME: Record<string, string> = { month_start_of: "month_start", month_end_of: "month_end" };
+
+  // §50: точность — Integer либо Decimal, режим — Text (DECISION-0259 п. 3).
+  const policyKinds = (fn: string, ks: string[]): void => {
+    if (ks[0] !== INT && ks[0] !== DEC) throw new RT.Refused(fn + " вне среза генератора: точность не Integer и не Decimal (§50)");
+    if (ks[1] !== TEXT) throw new RT.Refused(fn + " вне среза генератора: режим не Text (§50)");
+  };
+
+  // Литерал-терм §53 как typed-значение; тип сущности у entity_ref — "entity".
+  const typedArg = (a: any): Typed => {
+    if (a.kind === "entity_ref") return { v: a.id as string, t: "entity" };
+    if (a.kind === "const_ref") {
+      // DECISION-0273: параметр A3 в вопросе `term` — за срезом раннера (значение на legalTime дела).
+      if (M.A3_TYPES[a.id] !== undefined) throw new RT.Refused("параметр A3 в вопросе вне среза раннера: " + String(a.id));
+      const c = M.CONSTS[a.id];
+      if (c === undefined) return { v: RT.sym(String(a.id)), t: "enum" };
+      return { v: c[1], t: c[0] };
+    }
+    if (a.kind === "value") {
+      const t = a.type?.name;
+      if (t === MON || t === DEC || t === INT || t === TEXT || t === DATE || t === RAT || t === QTY || t === BOOL || t === NAT || t === INSTANT) return { v: arg(a), t };
+      throw new RT.Refused("аргумент вне среза раннера: " + String(t));
+    }
+    throw new RT.Refused("узел терма вне среза раннера: " + String(a.kind));
+  };
+
+  const slotTyped = (pred: string, col: number, v: Val): Typed => {
+    const t = M.PARAMS[pred][col];
+    if (typeof v === "string") {
+      const ent = ENTITIES.has(v), txt = TEXTS.has(v);
+      if (ent && txt) throw new RT.Refused("одна запись подана делом и сущностью, и Text: вид результата не определён в срезе");
+      if (ent) return { v, t: "entity" };
+      if (txt) return { v, t: TEXT };
+      return { v, t: t === TEXT ? TEXT : "entity" };
+    }
+    if (typeof v === "boolean") return { v, t: BOOL };
+    if (t === MON || t === DEC || t === INT || t === DATE || t === RAT || t === QTY || t === NAT || t === INSTANT) return { v, t };
+    return { v, t: RT.isSym(v) ? "enum" : "entity" };
+  };
+
+  const flatten = (body: any, atoms: any[], guards: any[]): void => {
+    const k = body?.kind;
+    if (k === "status") {
+      if (body.status !== "established") throw new RT.Refused("статусный тест вне L0-среза: " + String(body.status));
+      atoms.push(body.formula);
+    } else if (k === "literal") atoms.push(body);
+    else if (k === "comparison") guards.push(body);
+    else if (k === "and" || k === "conjunction") {
+      for (const s of body.items ?? body.args ?? body.operands ?? []) flatten(s, atoms, guards);
+    } else throw new RT.Refused("форма тела вне среза генератора: " + String(k));
+  };
+
+  const evalTerm = (node: any, env: Env): Typed => {
+    const k = node.kind;
+    if (k === "var") {
+      const b = env[node.var];
+      if (b === undefined) throw new RT.Refused("несвязанная переменная терма: " + String(node.var));
+      return b;
+    }
+    if (k === "value" && node.type?.name === RAT) {
+      // ERR-E0005: операнд вычисления разбирается как у оракула — сократимая
+      // запись нормализуется; каноничность §168.1 — у записей, не у операнда.
+      return { v: RT.ratTerm(node.value), t: RAT };
+    }
+    if (k === "value" || k === "entity_ref" || k === "const_ref") return typedArg(node);
+    if (k === "binary") {
+      const l = evalTerm(node.left, env), r = evalTerm(node.right, env);
+      const op = String(node.op);
+      if (CMP_OPS.includes(op)) {
+        // §57 (`values.binary`, `_check_same_kind`): валюта, единица, затем вид.
+        if (l.t === MON && r.t === MON && (l.v as RT.Money).cur !== (r.v as RT.Money).cur) throw new RT.TermError("CURRENCY_MISMATCH");
+        if (l.t === QTY && r.t === QTY && (l.v as RT.Qty).unit !== (r.v as RT.Qty).unit) throw new RT.TermError("DIMENSION_MISMATCH");
+        if ((l.t === DATE && r.t === INSTANT) || (l.t === INSTANT && r.t === DATE)) throw new RT.TermError("DATE_INSTANT_MISMATCH");
+        if (norm(l.t) !== norm(r.t)) throw new RT.TermError("TYPE_ERROR");
+        if (l.t === BOOL) {
+          // §57 (DECISION-0266): Boolean сравнимо только на равенство; порядок — TYPE_ERROR оракула.
+          if (op !== "eq" && op !== "ne") throw new RT.TermError("TYPE_ERROR");
+          return { v: RT.cmp(l.v, op, r.v), t: BOOL };
+        }
+        if (!isNumT(l.t) && l.t !== DATE && l.t !== INSTANT) throw new RT.Refused("операция вне среза раннера: " + op);
+        // Исход сравнения — булево §57 (DECISION-0266: Boolean — значение рантайма).
+        return { v: RT.cmp(l.v, op, r.v), t: BOOL };
+      }
+      if (!isNumT(l.t) || !isNumT(r.t)) throw new RT.Refused("арифметика вне среза (§58): не числовой операнд " + op);
+      if (!["add", "sub", "mul", "div", "mod"].includes(op)) throw new RT.Refused("операция вне среза раннера: " + op);
+      // §58 `values.binary` (DECISION-0252 п. 8): вид исхода — по значению;
+      // ошибка значения — TermError, ответ вопроса `term` — RUNTIME_ERROR.
+      const v = RT.arith(op, l.v, r.v, KIND_CODE[l.t], KIND_CODE[r.t]);
+      if (v instanceof RT.Rat) return { v, t: RAT };
+      if (RT.isMoney(v)) return { v, t: MON };
+      if (RT.isQty(v)) return { v, t: QTY };
+      return { v, t: norm(l.t) === INT && norm(r.t) === INT ? INT : DEC };
+    }
+    if (k === "call" && M.FUNCTIONS[String(node.function)] !== undefined) {
+      // DECISION-0273: функция §46 модуля; арность и типы аргументов — TYPE_ERROR
+      // оракула (`_require_type`), вид результата — объявленный.
+      const uf = M.FUNCTIONS[String(node.function)];
+      const args = (node.args ?? []).map((a: any) => evalTerm(a, env));
+      if (args.length !== uf.params.length) throw new RT.TermError("TYPE_ERROR");
+      args.forEach((a: Typed, i: number) => {
+        const want = uf.params[i];
+        const ok = want.startsWith("urn:law:std#") ? norm(a.t) === norm(want) : a.t === "enum" || a.t === want;
+        if (!ok) throw new RT.TermError("TYPE_ERROR");
+      });
+      return { v: uf.fn(args.map((a: Typed) => a.v)), t: uf.returns.startsWith("urn:law:std#") ? uf.returns : "enum" };
+    }
+    if (k === "call") {
+      const fn = String(node.function).split("#").pop() as string;
+      const args = (node.args ?? []).map((a: any) => evalTerm(a, env));
+      const t = callKind(fn, args.map((a: Typed) => a.t));
+      if (fn === "round") {
+        // DECISION-0259: политика §50 проверяется рантаймом; виды вопроса точные.
+        return { v: RT.round_mode(args[0].v, args[1].v, args[2].v, KIND_CODE[args[0].t], KIND_CODE[args[1].t]), t };
+      }
+      if (fn === "div_round") {
+        return { v: RT.div_round(args[0].v, args[1].v, args[2].v, args[3].v,
+                                 KIND_CODE[args[0].t], KIND_CODE[args[1].t], KIND_CODE[args[2].t]), t };
+      }
+      const f = (RT as any)[RT_NAME[fn] ?? fn] as (...a: Val[]) => Val;
+      return { v: f(...args.map((a: Typed) => a.v)), t };
+    }
+    if (k === "aggregate") return aggregate(node);
+    if (k === "if") {
+      // §56 (E-0180, DECISION-0270): чистое data-условие, ветвь вычисляется лениво.
+      return dataCond(node.condition, env) ? evalTerm(node.then, env) : evalTerm(node.else, env);
+    }
+    throw new RT.Refused("узел терма вне среза раннера: " + String(k));
+  };
+
+  // Data-условие §56 (`values.is_data_condition`): boolean, comparison, and, or.
+  const dataCond = (f: any, env: Env): boolean => {
+    const k = f?.kind;
+    if (k === "boolean") return Boolean(f.value);
+    if (k === "comparison") {
+      const v = evalTerm({ kind: "binary", op: f.op, left: f.left, right: f.right }, env);
+      return v.v as unknown as boolean;
+    }
+    if (k === "and") return (f.items ?? []).every((x: any) => dataCond(x, env));
+    if (k === "or") return (f.items ?? []).some((x: any) => dataCond(x, env));
+    throw new RT.Refused("условие терма §56 вне data-условия вне среза раннера: " + String(k));
+  };
+
+  // Материализация §52.1: элементы в порядке канонических байтов, distinct — множество.
+  const materialize = (comp: any): Typed[] => {
+    if (comp?.kind !== "comprehension") throw new RT.Refused("aggregate.input вне среза раннера");
+    if ((comp.binders ?? []).length) throw new RT.Refused("связки comprehension вне среза раннера");
+    const atoms: any[] = [], guards: any[] = [];
+    flatten(comp.generator, atoms, guards);
+    if (!atoms.length) throw new RT.Refused("тело без перебираемых атомов вне среза генератора");
+    for (const a of atoms) {
+      if (a.polarity !== "positive") throw new RT.Refused("отрицательный литерал в теле вне L0-среза");
+      if (!(a.predicate in M.PARAMS)) throw new RT.Refused("предикат comprehension не объявлен в пакете: " + String(a.predicate));
+      if ((a.args ?? []).length !== M.PARAMS[a.predicate].length) throw new RT.Refused("арность атома тела не совпадает с сигнатурой §189");
+    }
+    const out: { key: string; val: Typed }[] = [];
+    const seen = new Set<string>();
+    const walk = (i: number, env: Env): void => {
+      if (i === atoms.length) {
+        for (const g of guards) {
+          if (!RT.cmp(evalTerm(g.left, env).v, g.op, evalTerm(g.right, env).v)) return;
+        }
+        const val = evalTerm(comp.element, env);
+        const key = canon(literal(val));
+        if (comp.distinct) { if (seen.has(key)) return; seen.add(key); }
+        out.push({ key, val });
+        return;
+      }
+      const a = atoms[i];
+      // L1 (DECISION-0237): только установленные строки (TRUE_ONLY), без BOTH.
+      for (const row of M.established(a.predicate)) {
+        const next: Env = { ...env };
+        let ok = true;
+        for (let j = 0; j < row.length && ok; j++) {
+          const x = a.args[j];
+          if (x.kind === "var") {
+            const b = next[x.var];
+            if (b === undefined) next[x.var] = slotTyped(a.predicate, j, row[j]);
+            else if (!RT.eq(b.v, row[j])) ok = false;
+          } else if (!RT.eq(evalTerm(x, next).v, row[j])) ok = false;
+        }
+        if (ok) walk(i + 1, next);
+      }
+    };
+    walk(0, {});
+    out.sort((p, q) => cmpUtf8(p.key, q.key));
+    return out.map((e) => e.val);
+  };
+
+  const aggregate = (node: any): Typed => {
+    const items = materialize(node.input);
+    const op = String(node.op);
+    if (op === "count") return { v: RT.dec(String(items.length)), t: INT };
+    if (op === "only") {
+      // §51 (errata E-0256): функциональный lookup. Политика — TYPE_ERROR у
+      // оракула; пусто и два различных значения (канонические байты §208) —
+      // ошибки значения RUNTIME_ERROR, код тот же, что у оракула.
+      if (node.options && Object.keys(node.options).length) throw new RT.TermError("TYPE_ERROR");
+      if (!items.length) throw new RT.TermError("EMPTY_AGGREGATE");
+      if (new Set(items.map((it) => canon(literal(it)))).size > 1) throw new RT.TermError("CARDINALITY_CONFLICT");
+      return { v: items[0].v, t: norm(items[0].t) };
+    }
+    if (op !== "sum" && op !== "min" && op !== "max") throw new RT.Refused("агрегат вне среза раннера: " + op);
+    if (!items.length) {
+      const empty = node.options?.empty;
+      if (empty === undefined) throw new RT.Refused("EMPTY_AGGREGATE: " + op + " над пустой коллекцией без явной empty-политики (§59)");
+      // `from_literal_term` оракула: политика — LiteralTerm §53; иной узел даёт
+      // TYPE_ERROR раньше сверки вида.
+      if (empty?.kind !== "value") throw new RT.TermError("TYPE_ERROR");
+      const value = typedArg(empty);
+      // errata E-0195: вид политики обязан совпасть с видом элемента. У оракула
+      // это issue `TYPE_ERROR` с текстом «aggregate.empty: вид политики integer
+      // не совпадает с видом элемента коллекции money (§59)»; порождённый модуль
+      // сообщений не печатает вовсе, и байтовый контракт среза здесь — КОД issue,
+      // который тот же. До правки коллекция Money с политикой Integer отвечала
+      // `Integer 0` и `COMPUTED` — другой ответ, не меньший.
+      const expected = EMPTY_ELEMENT_KINDS[String(node.input?.variable?.type?.name)];
+      if (expected !== undefined && norm(value.t) !== expected) throw new RT.TermError("TYPE_ERROR");
+      return value;
+    }
+    let acc = items[0];
+    for (const it of items.slice(1)) {
+      if (!isNumT(acc.t) || norm(it.t) !== norm(acc.t)) throw new RT.Refused("арифметика вне среза (§58): виды операндов не совпадают у " + op);
+      if (op === "sum") acc = { v: RT.add(acc.v, it.v), t: acc.t };
+      else if (RT.cmp(it.v, op === "min" ? "lt" : "gt", acc.v)) acc = it;
+    }
+    if (!isNumT(acc.t)) throw new RT.Refused("арифметика вне среза (§58): не числовой операнд " + op);
+    // DECISION-0266: итог агрегата над Natural у оракула — вид `integer`, то есть Integer.
+    return { v: acc.v, t: norm(acc.t) };
+  };
+
+  // Каноническая десятичная запись §18/§208: без хвостовых нулей и minus-zero.
+  const canonDec = (d: RT.Dec): string => {
+    let { u, s } = d;
+    if (u === 0n) return "0";
+    while (s > 0 && u % 10n === 0n) { u /= 10n; s -= 1; }
+    const neg = u < 0n;
+    const body = (neg ? -u : u).toString().padStart(s + 1, "0");
+    const text = s === 0 ? body : body.slice(0, body.length - s) + "." + body.slice(body.length - s);
+    return (neg && u !== 0n ? "-" : "") + text;
+  };
+
+  // Литерал-терм §53 из typed-значения — ровно то, что печатает оракул.
+  const literal = (x: Typed): any => {
+    if (x.t === "entity") return { kind: "entity_ref", id: x.v };
+    if (x.t === "enum") return { kind: "const_ref", id: (x.v as RT.Sym).sym };
+    if (x.t === TEXT) return { kind: "value", type: { name: TEXT }, value: x.v };
+    if (x.t === DATE) return { kind: "value", type: { name: DATE }, value: (x.v as RT.Date).day };
+    if (x.t === INSTANT) return { kind: "value", type: { name: INSTANT }, value: (x.v as RT.Instant).at };
+    if (x.t === MON) return { kind: "value", type: { name: MON }, currency: (x.v as RT.Money).cur, value: canonDec(x.v as RT.Dec) };
+    if (x.t === DEC) return { kind: "value", type: { name: DEC }, value: canonDec(x.v as RT.Dec) };
+    if (x.t === RAT) {
+      const q = x.v as RT.Rat;
+      return { kind: "value", type: { name: RAT }, value: q.n.toString() + "/" + q.d.toString() };
+    }
+    if (x.t === BOOL) return { kind: "value", type: { name: BOOL }, value: Boolean(x.v) };
+    if (x.t === NAT) {
+      // DECISION-0266: запись дела хранит тип Natural; вычисленное целое — всегда Integer.
+      const d = x.v as RT.Dec;
+      return { kind: "value", type: { name: NAT }, value: { int: (d.u / 10n ** BigInt(d.s)).toString() } };
+    }
+    if (x.t === QTY) return { kind: "value", type: { name: QTY }, unit: (x.v as RT.Qty).unit, value: canonDec(x.v as RT.Dec) };
+    if (x.t === INT) {
+      const d = x.v as RT.Dec;
+      if (d.u % (10n ** BigInt(d.s)) !== 0n) throw new RT.Refused("Integer с дробной частью в результате");
+      return { kind: "value", type: { name: INT }, value: { int: (d.u / 10n ** BigInt(d.s)).toString() } };
+    }
+    throw new RT.Refused("вид результата вне среза раннера: " + x.t);
+  };
+
+  // Канонические байты §208 значения: ключи по порядку, без пробелов, целое — цифрами.
+  const canon = (v: any): string => {
+    if (v === null) return "null";
+    if (typeof v === "boolean") return v ? "true" : "false";
+    if (typeof v === "string") return JSON.stringify(v);
+    // Целое из JSON шаблона (payload позиции, DECISION-0242) — цифрами.
+    if (typeof v === "number") return String(v);
+    if (Array.isArray(v)) return "[" + v.map(canon).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) + ":" + canon(v[k])).join(",") + "}";
+  };
+
+  // Заземление payload шаблона подстановкой — порт `norms._ground_payload`.
+  const ground = (value: any, subst: Record<string, any>): any => {
+    if (Array.isArray(value)) return value.map((v) => ground(v, subst));
+    if (value !== null && typeof value === "object") {
+      if (value.kind === "var" && value.var in subst) return subst[value.var];
+      const out: Record<string, any> = {};
+      for (const k of Object.keys(value)) out[k] = ground(value[k], subst);
+      return out;
+    }
+    return value;
+  };
+
+  // E-0105: код ошибки терма → статус результата (`whynot.TERM_ERROR_STATUS`);
+  // код вне таблицы — RUNTIME_ERROR; старшинство — `TERM_ERROR_PRECEDENCE`.
+  const TERM_ERROR_STATUS: Record<string, string> = {
+    MISSING_POLICY: "MISSING_POLICY", DEADLINE_POLICY_INVALID: "MISSING_POLICY", MISSING_CALENDAR: "MISSING_INPUT",
+    CALENDAR_DATASET_INVALID: "MISSING_INPUT", CALENDAR_DATASET_HASH_MISMATCH: "MISSING_INPUT",
+    CALENDAR_OUT_OF_RANGE: "MISSING_INPUT", TYPE_ERROR: "TYPE_ERROR", CURRENCY_MISMATCH: "TYPE_ERROR",
+    DIMENSION_MISMATCH: "TYPE_ERROR", DATE_INSTANT_MISMATCH: "TYPE_ERROR", RESOURCE_LIMIT: "RESOURCE_LIMIT",
+    OPAQUE_NON_EXECUTABLE: "NON_EXECUTABLE", NON_EXHAUSTIVE_MATCH: "NON_EXECUTABLE", UNKNOWN_FUNCTION: "NON_EXECUTABLE",
+    NON_EXECUTABLE_FUNCTION_RECURSION: "NON_EXECUTABLE",
+  };
+  const TERM_ERROR_PRECEDENCE = ["MISSING_INPUT", "MISSING_POLICY", "NON_EXECUTABLE", "EXTERNAL_UNAVAILABLE",
+    "TYPE_ERROR", "RUNTIME_ERROR", "RESOURCE_LIMIT"];
+  const sortedJson = (v: any): string => {
+    if (Array.isArray(v)) return "[" + v.map(sortedJson).join(",") + "]";
+    if (v !== null && typeof v === "object") {
+      return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + sortedJson(v[k])).join(",") + "}";
+    }
+    return JSON.stringify(v);
+  };
+
+  // Порт `whynot.term_error_blockers` + `term_error_status`: правила с совместимой
+  // головой, их ошибки терма и конъюнкты без опоры — вглубь.
+  let LAST_TERM_CODES = new Set<string>();
+  const termErrorStatus = (goal: any): string | null => {
+    const Mx = M as any;
+    const byRule = new Map<string, string[]>();
+    for (const k of (Mx.ISSUE_SEEN ?? new Set<string>()) as Set<string>) {
+      const at = k.lastIndexOf("|"), name = k.slice(0, at), code = k.slice(at + 1);
+      if (code === "MISSING_PARAMETER_VALUE") continue;
+      byRule.set(name, [...(byRule.get(name) ?? []), code]);
+    }
+    if (byRule.size === 0) return null;
+    const index = new Map<string, any[]>();
+    for (const r of Mx.BACKCHAIN) index.set(r.head.predicate, [...(index.get(r.head.predicate) ?? []), r]);
+    const deref = (a: any): any => (a.kind === "const_ref" && a.id in Mx.BACKCHAIN_CONSTS ? Mx.BACKCHAIN_CONSTS[a.id] : a);
+    const compatible = (head: any, target: any): Record<string, any> | null => {
+      if ((head.polarity ?? "positive") !== (target.polarity ?? "positive")) return null;
+      if (head.args.length !== target.args.length) return null;
+      const subst: Record<string, any> = {};
+      for (let i = 0; i < head.args.length; i++) {
+        const h = head.args[i], g = target.args[i];
+        if (g.kind === "var") continue;
+        if (h.kind === "var") {
+          if (h.var in subst && sortedJson(subst[h.var]) !== sortedJson(g)) return null;
+          subst[h.var] = g;
+        } else if (!["entity_ref", "const_ref", "value"].includes(h.kind)) {
+          continue;
+        } else if (sortedJson(h) !== sortedJson(g)) {
+          return null;
+        }
+      }
+      return subst;
+    };
+    const MIRROR: Record<string, string> = { TRUE_ONLY: "FALSE_ONLY", FALSE_ONLY: "TRUE_ONLY", BOTH: "BOTH", NEITHER: "NEITHER" };
+    const truth = (lit: any): string => {
+      const ents = new Set(ENTITIES), txts = new Set(TEXTS);
+      try {
+        const st: string = Mx.status(lit.predicate, lit.args.map(arg));
+        return lit.polarity === "negative" ? MIRROR[st] : st;
+      } finally {
+        ENTITIES.clear(); ents.forEach((x) => ENTITIES.add(x)); TEXTS.clear(); txts.forEach((x) => TEXTS.add(x));
+      }
+    };
+    const found = new Set<string>(), visited = new Set<string>();
+    const walk = (target: any): void => {
+      const key = sortedJson(target);
+      if (visited.has(key)) return;
+      visited.add(key);
+      for (const r of index.get(target.predicate) ?? []) {
+        const subst = compatible(r.head, target);
+        if (subst === null) continue;
+        const w = r.window;
+        if (w && ((w.start && RT.legalTime() < w.start) || (w.end && RT.legalTime() >= w.end))) continue;
+        for (const c of byRule.get(r.name) ?? []) found.add(c);
+        for (const [, lit] of r.body) {
+          if (lit.kind !== "literal") continue;  // DECISION-0274: гарды в backchain — только для пути судьи
+          const args: any[] = lit.args ?? [];
+          if (args.some((a) => a.kind === "wildcard")) continue;
+          // DECISION-0270: вычисляемый аргумент (binary/call/if) не заземляется
+          // обходом — как несвязанная переменная, конъюнкт идёт вглубь без оценки.
+          const computed = (a: any): boolean => ["binary", "call", "if", "let", "match"].includes(a?.kind);
+          if (args.some((a) => (a.kind === "var" && !(a.var in subst)) || computed(a) || (a.kind === "var" && computed(subst[a.var])))) {
+            walk({ ...lit, args: args.map((a) => (a.kind === "var" && a.var in subst ? subst[a.var] : a)) });
+            continue;
+          }
+          const ground = { ...lit, args: args.map((a) => (a.kind === "var" ? subst[a.var] : a)) };
+          if (truth(ground) === "NEITHER") walk(ground);
+        }
+      }
+    };
+    walk({ ...goal, args: (goal.args ?? []).map(deref) });
+    LAST_TERM_CODES = new Set(found);
+    const statuses = new Set([...found].map((c) => TERM_ERROR_STATUS[c] ?? "RUNTIME_ERROR"));
+    return TERM_ERROR_PRECEDENCE.find((st) => statuses.has(st)) ?? null;
+  };
+
+  // E-0243 §181.2: assertion TYPE_ERROR blocks precisely relations reading it.
+  const carrierTypeError = (goal: any): string | null => {
+    if (TYPE_ERROR_PREDICATES.size === 0) return null;
+    const Mx = M as any, index: Record<string, string[]> = Mx.CARRIER_EDGES ?? {}, seen = new Set<string>();
+    const walk = (pred: string): boolean => {
+      if (seen.has(pred)) return false; seen.add(pred);
+      return TYPE_ERROR_PREDICATES.has(pred) || (index[pred] ?? []).some(walk);
+    };
+    return walk(goal.predicate) ? "TYPE_ERROR" : null;
+  };
+
+  // §175/§181.2 (errata E-0265): статус результата, зависящего от упавшего правила.
+  // NEITHER над ошибкой терма — статус кода (E-0105); иная истинность — итог §181.2:
+  // код из списка ниже остаётся статусом, прочие — NON_EXECUTABLE. Если коды
+  // смешаны, итог оракула решает первая блокирующая issue документа — порядок,
+  // которого раннер не воспроизводит: названный отказ.
+  const OUTCOME_CODES = new Set(["PRIORITY_CONFLICT", "INTERPRETATION_REQUIRED", "TYPE_ERROR",
+    "RESOURCE_LIMIT", "CONFLICTED_INPUTS", "SOURCE_RESOLUTION_FAILED"]);
+  const ruleErrorStatus = (goal: any, truth: string): string | null => {
+    const te = termErrorStatus(goal);
+    const codes = new Set(te !== null ? LAST_TERM_CODES : []);
+    const ct = carrierTypeError(goal);
+    if (te === null && ct === null) return null;
+    if (truth === "NEITHER") return (te ?? ct) as string;
+    if (ct !== null) codes.add("TYPE_ERROR");
+    const kept = [...codes].filter((c) => OUTCOME_CODES.has(c));
+    if (kept.length === 0) return "NON_EXECUTABLE";
+    if (kept.length === codes.size && new Set(kept).size === 1) return kept[0];
+    throw new RT.Refused("статус итога §181.2 зависит от порядка issue вне среза раннера");
+  };
+
+  // Обход запроса судье §47.3 (DECISION-0274): переводы термов раннера для рантайма;
+  // множества сущностей и текстов дела обходом не двигаются.
+  const jhooks: RT.JHooks = {
+    val: (t: any): Val => {
+      const ents = new Set(ENTITIES), txts = new Set(TEXTS);
+      try { return arg(t); } finally { ENTITIES.clear(); ents.forEach((x) => ENTITIES.add(x)); TEXTS.clear(); txts.forEach((x) => TEXTS.add(x)); }
+    },
+    cell: (pred: string, col: number, v: Val): any => literal(slotTyped(pred, col, v)),
+  };
+  const judgmentRequests = (goal: any, status: string, conflict: boolean, tail: string): any[] =>
+    RT.buildRequests(M, RT.judgmentBlockers(M, jhooks, { ...goal, polarity: goal.polarity ?? "positive" }, status, conflict), tail);
+
+  // Порт `context.expand` без дозаполнения: профили §89.1 от корня к листу, затем дело.
+  const effectiveContext = (kase: any): Record<string, any> => {
+    const raw: Record<string, any> = { ...(kase.context ?? {}) };
+    const profiles = kase.contextProfiles ?? {};
+    const parent = raw.extends ?? null;
+    delete raw.extends;
+    const chain: string[] = [], seen = new Set<string>();
+    let current: string | null = parent;
+    while (current !== null && current !== undefined) {
+      if (seen.has(current)) throw new RT.Refused("CONTEXT_PROFILE_CYCLE: цикл наследования профилей (§89.1)");
+      if (!(current in profiles)) throw new RT.Refused("CONTEXT_PROFILE_MISSING: профиль не определён (§89.1)");
+      seen.add(current);
+      chain.push(current);
+      current = profiles[current].extends ?? null;
+    }
+    const effective: Record<string, any> = {};
+    for (const name of chain.reverse()) Object.assign(effective, profiles[name].fields ?? {});
+    return Object.assign(effective, raw);
+  };
+
+  const keyConflictBlocks = (predicate: string): boolean => {
+    const tainted = new Set<string>((M as any).keyConflictPredicates());
+    const waiting = [...tainted];
+    while (waiting.length) {
+      const source = waiting.pop()!;
+      for (const consumer of ((M as any).KEY_READERS?.[source] ?? [])) {
+        if (!tainted.has(consumer)) { tainted.add(consumer); waiting.push(consumer); }
+      }
+    }
+    return tainted.has(predicate);
+  };
+
+  // Политика §86 и снимок §85 дела до вывода (DECISION-0245 п. 4): порт
+  // `engine._resolve_deadline_policy` и `engine._calendar_snapshot`.
+  const calendarSetup = (kase: any): void => {
+    const Mx = M as any;
+    const ref = effectiveContext(kase).deadlinePolicy;
+    let policy: Record<string, any> | null = null;
+    if (ref !== undefined && ref !== null) {
+      if (String(Mx.CAL_SEMVER).startsWith("0.1")) {
+        if (typeof ref !== "object" || Array.isArray(ref)) throw new RT.Refused("case.context.deadlinePolicy вне среза раннера (§86)");
+        policy = ref;
+      } else if (typeof ref !== "string") {
+        throw new RT.Refused("case.context.deadlinePolicy: в 0.2 ожидался DeadlinePolicyRef (DECISION-0111 §2.9)");
+      } else if (!(ref in Mx.CAL_POLICIES)) {
+        throw new RT.Refused("case.context.deadlinePolicy: ссылка не разрешена в закреплённом CLIR (§86)");
+      } else {
+        policy = Mx.CAL_POLICIES[ref];
+      }
+    }
+    const selected = kase.options?.calendarSnapshot;
+    const snapshots: RT.Snapshot[] = Mx.CAL_SNAPSHOTS;
+    let snapshot: RT.Snapshot | null = null;
+    if (selected) {
+      snapshot = snapshots.find((c) => c.id === selected) ?? null;
+      if (snapshot === null) throw new RT.Refused("MISSING_CALENDAR: calendar_snapshot не объявлен в программе (§85, §168.2)");
+    } else if (snapshots.length >= 2) {
+      throw new RT.Refused("AMBIGUOUS_CALENDAR: в программе несколько calendar_snapshot без выбора (§85, §168.2)");
+    } else if (snapshots.length === 1) {
+      snapshot = snapshots[0];
+    }
+    RT.setCalendar(policy, snapshot);
+  };
+
+
+  // Внутренний вид API `rows` (DECISION-0423 §2.1): установленные строки вопроса
+  // литерал-термами §53, статус вычисления — как у вопроса о том же отношении.
+  const rowsAnswer = (query: any): any => {
+    const pred = String(query.predicate);
+    if (!(pred in M.PARAMS)) throw new RT.Refused("предикат rows не объявлен в пакете: " + pred);
+    const src: Val[][] = M.LAYER === "L1" ? (M as any).established(pred) : (M.TABLES[pred] ?? []);
+    const rows = src.map((r) => r.map((v, col) => literal(slotTyped(pred, col, v))));
+    rows.sort((p, q) => cmpUtf8(canon(p), canon(q)));
+    const evaluation = keyConflictBlocks(pred) ? "NON_EXECUTABLE" : "COMPUTED";
+    return { queryId: query.queryId, resultKind: "COLLECTION", rows, evaluationStatus: evaluation,
+             judgmentRequests: [], issues: [...ISSUES] };
+  };
+
+  // --- исполнение ---
+  RT.setLegalTime(String(kase.context?.legalTime ?? ""));
+  // E-0212 §135.1: only an explicitly supplied decision changes status time.
+  if (Object.prototype.hasOwnProperty.call(kase.context ?? {}, "decisionTime") &&
+      typeof (M as any).setStatusTime === "function") {
+    (M as any).setStatusTime(String(kase.context.decisionTime).slice(0, 10));
+  }
+  if ((M as any).CAL_SNAPSHOTS !== undefined) calendarSetup(kase);
+
+  for (const a of kase.assertions ?? []) {
+    if (a.valid != null) throw new RT.Refused("поле assertion.valid вне среза раннера (§72)");
+    const lit = a.literal;
+    if (lit.polarity !== "positive" && (M.LAYER !== "L1" || lit.polarity !== "negative")) {
+      throw new RT.Refused("§113: отрицательный факт вне L0-среза");
+    }
+    if (lit.predicate === "urn:law:std#incompatible" && "POSITIONS" in M) {
+      // §105.1: явная несовместимость позиций — конфликт вне среза (DECISION-0242 K5).
+      throw new RT.Refused("конфликт позиций §105.1 (incompatible) вне среза раннера (DECISION-0242 K5)");
+    }
+    if (!wellTyped(lit)) continue;
+    if (!(lit.predicate in M.PARAMS)) continue;
+    // §47.3.1 (E-0089, DECISION-0274): ответ судьи не от того органа или не по форме — не принят.
+    const rejected = RT.judgmentAnswer(M, a);
+    if (rejected !== null) { ISSUES.push(rejected); continue; }
+    if (lit.polarity === "negative") M.registerNegative(lit.predicate, lit.args.map(arg));
+    else M.register(lit.predicate, lit.args.map(arg));
+  }
+  M.saturate();
+  if (opts.stats !== undefined && M.LAYER === "L1" && (M as any).STATS !== undefined) Object.assign(opts.stats, (M as any).STATS);
+  // DECISION-0239 G3: ошибки значения агрегатов в правилах — issues модели.
+  ISSUES.push(...(((M as any).RULE_ISSUES ?? []) as string[]));
+  // DECISION-0242: диагностики эффектов полномочий §127–§128.
+  ISSUES.push(...(((M as any).NORM_ISSUES ?? []) as string[]));
+  for (let n = M.keyConflicts(); n > 0; n--) ISSUES.push("KEY_CONFLICT");
+
+  if (query.kind === "rows" && opts.api) return rowsAnswer(query);
+  if (query.kind === "collect") {
+    const elements = materialize(query.comprehension);
+    if (elements.some((e) => typeof e.v === "string" && e.v.startsWith("urn:position:"))) {
+      throw new RT.Refused("позиция в элементе коллекции вне среза раннера (DECISION-0242 K4)");
+    }
+    return { queryId: query.queryId, resultKind: "COLLECTION", value: elements.map((e) => literal(e)),
+             evaluationStatus: "COMPUTED", issues: [...ISSUES] };
+  }
+  if (query.kind === "term") {
+    let value: any;
+    try {
+      value = literal(evalTerm(query.term, {}));
+    } catch (e) {
+      if (!(e instanceof RT.TermError)) throw e;
+      // §58/§175 (DECISION-0252 п. 8): ошибка значения вопроса — без значения;
+      // статус по таблице `queries.query_calc`: несовместимость видов —
+      // TYPE_ERROR, прочее — RUNTIME_ERROR.
+      const status = ["TYPE_ERROR", "CURRENCY_MISMATCH", "DIMENSION_MISMATCH", "DATE_INSTANT_MISMATCH"]
+        .includes(e.code) ? "TYPE_ERROR" : "RUNTIME_ERROR";
+      return { queryId: query.queryId, resultKind: "DATA", evaluationStatus: status, issues: [...ISSUES, e.code] };
+    }
+    return { queryId: query.queryId, resultKind: "DATA", value, evaluationStatus: "COMPUTED", issues: [...ISSUES] };
+  }
+  if (query.kind !== "truth") throw new RT.Refused("вид запроса вне среза раннера: " + String(query.kind));
+  if ((query.literal.args ?? []).some((x: any) => x.kind === "entity_ref" && String(x.id).startsWith("urn:position:"))) {
+    throw new RT.Refused("позиция в аргументе вопроса вне среза раннера (DECISION-0242 K4)");
+  }
+  const tail = String(query.queryId).split(":").pop() as string;
+  if (M.LAYER === "L1") {
+    // §62/§63: статус атома по опорам обеих полярностей; отрицательный вопрос
+    // зеркалит стороны; несогласованный по сигнатуре вопрос — NEITHER.
+    const MIRROR: Record<string, string> = { TRUE_ONLY: "FALSE_ONLY", FALSE_ONLY: "TRUE_ONLY", BOTH: "BOTH", NEITHER: "NEITHER" };
+    let status = "NEITHER";
+    if (queryTyped(query.literal)) status = M.status(query.literal.predicate, query.literal.args.map(arg));
+    if (query.literal.polarity === "negative") status = MIRROR[status];
+    let evaluation = "COMPUTED";
+    const blocked: Set<string> | undefined = (M as any).BLOCKED;
+    const conflict = blocked !== undefined && query.literal.predicate in M.PARAMS
+        && blocked.has(query.literal.predicate + "\u0000" + RT.key(query.literal.args.map(arg)));
+    // §47.3 (DECISION-0274): судьи по лестнице §175 — конфликт старше судьи, судья старше ошибки терма.
+    const requests = judgmentRequests(query.literal, status, conflict, tail);
+    if (conflict) {
+      // §127: эффект заперт непобеждённой парой Power/Immunity.
+      evaluation = "UNRESOLVED_NORMATIVE_CONFLICT";
+    } else if (keyConflictBlocks(query.literal.predicate)) {
+      evaluation = "NON_EXECUTABLE";
+    } else if (requests.length > 0) {
+      evaluation = "REQUIRES_JUDGMENT";
+    } else if (termErrorStatus(query.literal) !== null || carrierTypeError(query.literal) !== null) {
+      evaluation = ruleErrorStatus(query.literal, status) as string;
+    } else if (status === "NEITHER" && (M as any).BACKCHAIN !== undefined) {
+      // E-0105 (§175/§185): NEITHER над ошибкой терма правила-кандидата.
+      evaluation = termErrorStatus(query.literal) ?? evaluation;
+    }
+    return { queryId: query.queryId, truthStatus: status, evaluationStatus: evaluation, judgmentRequests: requests, issues: [...ISSUES] };
+  }
+  // Ключ атома у оракула §208 включает ТИП значения: запрос с Integer к
+  // утверждению Decimal той же величины атома не находит — NEITHER без issue.
+  let hit = false;
+  if (queryTyped(query.literal)) {
+    const want = query.literal.args.map(arg);
+    const rows = M.TABLES[query.literal.predicate] ?? [];
+    hit = rows.some((row) => row.length === want.length && row.every((v, i) => RT.eq(v, want[i])));
+  }
+  // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+  // §47.3 (DECISION-0274): судьи у модели L0 — тот же обход по `backchain`.
+  const status0 = hit ? "TRUE_ONLY" : "NEITHER";
+  const requests0 = judgmentRequests(query.literal, status0, false, tail);
+  return {
+    queryId: query.queryId,
+    truthStatus: status0,
+    evaluationStatus: keyConflictBlocks(query.literal.predicate) ? "NON_EXECUTABLE"
+      : (requests0.length > 0 ? "REQUIRES_JUDGMENT" : (ruleErrorStatus(query.literal, status0) ?? "COMPUTED")),
+    judgmentRequests: requests0,
+    issues: [...ISSUES],
+  };
+};