arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/dart/json.dart

@@ -0,0 +1,166 @@
+// Разбор JSON с числами ТЕКСТОМ: `jsonDecode` ядра превращает запись числа в
+// int (64 бита) или double, а длинное целое — в double с потерей цифр.
+// Число здесь — JNum с исходной записью; строки, массивы, объекты, true/false
+// и null — обычные значения Dart.
+library json;
+
+import 'dart:convert';
+import 'dart:io';
+
+class JNum {
+  final String text;
+  const JNum(this.text);
+  @override
+  String toString() => text;
+}
+
+class _P {
+  final String s;
+  int i = 0;
+  _P(this.s);
+
+  Never fail(String what) => throw FormatException('JSON: $what в позиции $i');
+
+  void ws() {
+    while (i < s.length && ' \t\r\n'.contains(s[i])) {
+      i++;
+    }
+  }
+
+  Object? value() {
+    ws();
+    if (i >= s.length) fail('конец входа');
+    final c = s[i];
+    if (c == '{') {
+      i++;
+      final obj = <String, Object?>{};
+      ws();
+      if (s[i] == '}') {
+        i++;
+        return obj;
+      }
+      while (true) {
+        ws();
+        if (s[i] != '"') fail('ожидался ключ');
+        final k = string();
+        ws();
+        if (s[i] != ':') fail("ожидалось ':'");
+        i++;
+        obj[k] = value();
+        ws();
+        if (s[i] == '}') {
+          i++;
+          return obj;
+        }
+        if (s[i] != ',') fail("ожидалось ',' или '}'");
+        i++;
+      }
+    }
+    if (c == '[') {
+      i++;
+      final arr = <Object?>[];
+      ws();
+      if (s[i] == ']') {
+        i++;
+        return arr;
+      }
+      while (true) {
+        arr.add(value());
+        ws();
+        if (s[i] == ']') {
+          i++;
+          return arr;
+        }
+        if (s[i] != ',') fail("ожидалось ',' или ']'");
+        i++;
+      }
+    }
+    if (c == '"') return string();
+    if (s.startsWith('true', i)) {
+      i += 4;
+      return true;
+    }
+    if (s.startsWith('false', i)) {
+      i += 5;
+      return false;
+    }
+    if (s.startsWith('null', i)) {
+      i += 4;
+      return null;
+    }
+    final m = RegExp(r'-?\d+(\.\d+)?([eE][-+]?\d+)?').matchAsPrefix(s, i);
+    if (m == null) fail('неизвестное значение');
+    i = m.end;
+    return JNum(m.group(0)!);
+  }
+
+  String string() {
+    i++;
+    final out = StringBuffer();
+    while (true) {
+      if (i >= s.length) fail('строка не закрыта');
+      final c = s[i];
+      if (c == '"') {
+        i++;
+        return out.toString();
+      }
+      if (c == '\\') {
+        final e = s[i + 1];
+        i += 2;
+        switch (e) {
+          case '"':
+          case '\\':
+          case '/':
+            out.write(e);
+            break;
+          case 'b':
+            out.write('\b');
+            break;
+          case 'f':
+            out.write('\f');
+            break;
+          case 'n':
+            out.write('\n');
+            break;
+          case 'r':
+            out.write('\r');
+            break;
+          case 't':
+            out.write('\t');
+            break;
+          case 'u':
+            // Суррогатные пары складываются сами: строка Dart — UTF-16.
+            out.writeCharCode(int.parse(s.substring(i, i + 4), radix: 16));
+            i += 4;
+            break;
+          default:
+            fail('плохой экран');
+        }
+      } else {
+        out.write(c);
+        i++;
+      }
+    }
+  }
+}
+
+Object? decode(String s) {
+  final p = _P(s);
+  final v = p.value();
+  p.ws();
+  if (p.i != s.length) p.fail('лишнее после значения');
+  return v;
+}
+
+Object? readJson(String path) => decode(File(path).readAsStringSync(encoding: utf8));
+
+/// Текст значения JSON: строка как есть, число — его запись.
+String text(Object? v) => v == null ? '' : v.toString();
+
+/// Строка JSON печатается байтами UTF-8 явно: кодировка stdout по умолчанию
+/// берётся из системы, и на чужой машине UTF-8 вышел бы latin1.
+void emitLine(String line) {
+  stdout.add(utf8.encode('$line\n'));
+}
+
+String str(String s) => jsonEncode(s);

arxo_codegen/targets/dart/runner.dart

@@ -0,0 +1,154 @@
+// Раннер Dart-бэкенда: тот же вход и тот же ответ, что у runner.rb.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+// целями; любое другое исключение — крах, который ворота валят. Код выхода
+// ставится через `exitCode`, а не `exit()`: `exit()` не дожидается записи
+// stdout, и отказ терял бы свой JSON.
+import 'dart:io';
+
+import 'json.dart' as J;
+import 'model.dart' as M;
+import 'runtime.dart';
+
+final List<String> issues = [];
+
+Object? field(Object? m, String k) => m is Map<String, Object?> ? m[k] : null;
+
+Object arg(Object? a) {
+  final kind = field(a, 'kind');
+  if (kind == 'entity_ref') return J.text(field(a, 'id'));
+  if (kind == 'const_ref') {
+    // §54: разыменование предшествует исполнению; член перечисления §38 либо
+    // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+    final c = M.CONSTS[field(a, 'id')];
+    return c == null ? RT.sym(J.text(field(a, 'id'))) : c[1];
+  }
+  if (kind != 'value') throw Refused('аргумент вне среза раннера: ${J.text(kind)}');
+  final t = field(field(a, 'type'), 'name');
+  final v = J.text(field(a, 'value'));
+  switch (t) {
+    case 'urn:law:std#Money':
+      return RT.money(v, J.text(field(a, 'currency')));
+    case 'urn:law:std#Decimal':
+    case 'urn:law:std#Integer':
+      return RT.dec(v);
+    case 'urn:law:std#Text':
+      return v;
+    case 'urn:law:std#Date':
+      return RT.date(v);
+  }
+  throw Refused('аргумент вне среза раннера: ${J.text(t)}');
+}
+
+// Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+// константы; entity_ref типа не несёт (как у оракула).
+String? argType(Object? a) {
+  if (field(a, 'kind') == 'value') return field(field(a, 'type'), 'name') as String?;
+  if (field(a, 'kind') == 'const_ref') return M.CONSTS[field(a, 'id')]?[0] as String?;
+  return null;
+}
+
+// Совпадение типа с наследованием сущностей вверх от фактического.
+bool conforms(String actual, String expected) {
+  final seen = <String>{};
+  String? cur = actual;
+  while (cur != null && seen.add(cur)) {
+    if (cur == expected) return true;
+    cur = M.BASES[cur];
+  }
+  return false;
+}
+
+// Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+bool wellTyped(Object? lit) {
+  final params = M.PARAMS[field(lit, 'predicate')];
+  if (params == null) return true;
+  final args = (field(lit, 'args') as List?) ?? const [];
+  if (args.length != params.length) {
+    issues.add('TYPE_ERROR');
+    return false;
+  }
+  for (var i = 0; i < params.length; i++) {
+    final actual = argType(args[i]);
+    if (actual != null && !conforms(actual, params[i])) {
+      issues.add('TYPE_ERROR');
+      return false;
+    }
+  }
+  return true;
+}
+
+// Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+// атома не находит — NEITHER без issue.
+bool queryTyped(Object? lit) {
+  final params = M.PARAMS[field(lit, 'predicate')];
+  if (params == null) return false;
+  final args = (field(lit, 'args') as List?) ?? const [];
+  if (args.length != params.length) return false;
+  for (var i = 0; i < params.length; i++) {
+    final actual = argType(args[i]);
+    if (actual != null && !conforms(actual, params[i])) return false;
+  }
+  return true;
+}
+
+bool keyConflictBlocks(String predicate) {
+  final tainted = M.keyConflictPredicates();
+  final waiting = <String>[...tainted];
+  while (waiting.isNotEmpty) {
+    final source = waiting.removeLast();
+    for (final consumer in M.KEY_READERS[source] ?? const <String>[]) {
+      if (tainted.add(consumer)) waiting.add(consumer);
+    }
+  }
+  return tainted.contains(predicate);
+}
+
+void run(List<String> argv) {
+  final kase = J.readJson(argv[0]);
+  final query = J.readJson(argv[1]);
+  RT.setLegalTime(J.text(field(field(kase, 'context'), 'legalTime')));
+  M.packageFacts();
+  for (final a in field(kase, 'assertions') as List) {
+    final lit = field(a, 'literal');
+    if (field(lit, 'polarity') != 'positive') throw Refused('§113: отрицательный факт вне L0-среза');
+    if (!wellTyped(lit)) continue;
+    final pred = field(lit, 'predicate') as String;
+    if (!M.PARAMS.containsKey(pred)) continue;
+    M.register(pred, (field(lit, 'args') as List).map(arg).toList());
+  }
+  M.saturate();
+  for (var i = M.keyConflicts(); i > 0; i--) {
+    issues.add('KEY_CONFLICT');
+  }
+  if (field(query, 'kind') != 'truth') {
+    throw Refused('вид запроса вне среза раннера: ${J.text(field(query, 'kind'))}');
+  }
+  var hit = false;
+  final ql = field(query, 'literal');
+  if (queryTyped(ql)) {
+    final want = (field(ql, 'args') as List).map(arg).toList();
+    final rows = M.TABLES[field(ql, 'predicate')] ?? const <List<Object>>[];
+    hit = rows.any((r) {
+      if (r.length != want.length) return false;
+      for (var i = 0; i < r.length; i++) {
+        if (!RT.eq(r[i], want[i])) return false;
+      }
+      return true;
+    });
+  }
+  // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+  J.emitLine('{"queryId":${J.str(J.text(field(query, 'queryId')))},'
+      '"truthStatus":${J.str(hit ? 'TRUE_ONLY' : 'NEITHER')},'
+      '"evaluationStatus":${J.str(keyConflictBlocks(field(ql, 'predicate') as String) ? 'NON_EXECUTABLE' : 'COMPUTED')},"issues":[${issues.map(J.str).join(',')}]}');
+}
+
+void main(List<String> argv) {
+  try {
+    run(argv);
+  } on Refused catch (e) {
+    J.emitLine('{"refused":${J.str(e.message)}}');
+    exitCode = 3;
+  }
+}

arxo_codegen/targets/dart/runtime.dart

@@ -0,0 +1,293 @@
+// Рантайм L0 для Dart. Тот же контракт, что у runtime.rb: точная десятичная
+// арифметика §58 на BigInt ядра, деньги с валютой, названный режим
+// округления, календарный день, член перечисления.
+//
+// Ловушка Dart: `%` у BigInt евклидов, а `~/` усекает к нулю — остаток с
+// усечением даёт только `remainder`.
+library runtime;
+
+/// Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+/// печатает его как JSON с кодом выхода 3; любое другое исключение — крах.
+class Refused implements Exception {
+  final String message;
+  Refused(this.message);
+  @override
+  String toString() => message;
+}
+
+class Dec {
+  final BigInt u;
+  final int s;
+  const Dec(this.u, this.s);
+}
+
+class Money {
+  final BigInt u;
+  final int s;
+  final String cur;
+  const Money(this.u, this.s, this.cur);
+}
+
+/// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD: порядок
+/// записи и есть порядок дня. Не String: у ключа атома и у сравнения свой вид.
+class LDate {
+  final String v;
+  const LDate(this.v);
+}
+
+/// Член перечисления §38 либо иная ссылка const_ref без объявления: значение —
+/// stable qualified identity, равенство по ней (§57), порядок не определён.
+class Sym {
+  final String id;
+  const Sym(this.id);
+}
+
+final BigInt _ten = BigInt.from(10);
+BigInt _p10(int k) => _ten.pow(k);
+
+class RT {
+  static Dec dec(String lit) {
+    final dot = lit.indexOf('.');
+    final i = dot < 0 ? lit : lit.substring(0, dot);
+    final f = dot < 0 ? '' : lit.substring(dot + 1);
+    final neg = i.startsWith('-');
+    final digits = (neg ? i.substring(1) : i) + f;
+    return Dec(BigInt.parse((neg ? '-' : '') + digits), f.length);
+  }
+
+  static Money money(String lit, String cur) {
+    final d = dec(lit);
+    return Money(d.u, d.s, cur);
+  }
+
+  static LDate date(String lit) => LDate(lit);
+  static Sym sym(String id) => Sym(id);
+
+  static bool _num(Object v) => v is Dec || v is Money;
+  static BigInt _u(Object v) => v is Money ? v.u : (v as Dec).u;
+  static int _s(Object v) => v is Money ? v.s : (v as Dec).s;
+
+  // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+  static void _same(Object a, Object b, String op) {
+    if (!(_num(a) && _num(b) && (a is Money) == (b is Money))) {
+      throw Refused('§58: виды операндов не совпадают: $op');
+    }
+    if (a is Money && a.cur != (b as Money).cur) throw Refused('§58: разные валюты: $op');
+  }
+
+  static List<Object> _pair(Object a, Object b) {
+    final s = _s(a) > _s(b) ? _s(a) : _s(b);
+    return [_u(a) * _p10(s - _s(a)), _u(b) * _p10(s - _s(b)), s];
+  }
+
+  static Object _make(BigInt u, int s, Object like) => like is Money ? Money(u, s, like.cur) : Dec(u, s);
+
+  // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+  static bool _integral(Object v) => v is Dec && v.u.remainder(_p10(v.s)) == BigInt.zero;
+  static BigInt _toInt(Dec v) => v.u ~/ _p10(v.s);
+
+  static Object add(Object a, Object b) {
+    _same(a, b, 'add');
+    final p = _pair(a, b);
+    return _make((p[0] as BigInt) + (p[1] as BigInt), p[2] as int, a);
+  }
+
+  static Object sub(Object a, Object b) {
+    _same(a, b, 'sub');
+    final p = _pair(a, b);
+    return _make((p[0] as BigInt) - (p[1] as BigInt), p[2] as int, a);
+  }
+
+  // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+  // сумма масштабов. Два размерных не перемножаются.
+  static Object mul(Object a, Object b) {
+    if (!(_num(a) && _num(b))) throw Refused('§58: виды операндов не совпадают: mul');
+    if (a is Money && b is Money) throw Refused('§58: произведение двух размерных величин не определено');
+    return _make(_u(a) * _u(b), _s(a) + _s(b), a is Money ? a : b);
+  }
+
+  // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе null.
+  static List<Object>? _exact(BigInt num, BigInt den) {
+    var g = num.gcd(den);
+    if (g == BigInt.zero) g = BigInt.one;
+    num = num ~/ g;
+    den = den ~/ g;
+    if (den.isNegative) {
+      num = -num;
+      den = -den;
+    }
+    final two = BigInt.two, five = BigInt.from(5);
+    var twos = 0, fives = 0;
+    while (den.remainder(two) == BigInt.zero) {
+      den = den ~/ two;
+      twos++;
+    }
+    while (den.remainder(five) == BigInt.zero) {
+      den = den ~/ five;
+      fives++;
+    }
+    if (den != BigInt.one) return null;
+    final k = twos > fives ? twos : fives;
+    return [num * two.pow(k - twos) * five.pow(k - fives), k];
+  }
+
+  // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+  // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+  static Object div(Object a, Object b) {
+    if (!(_num(a) && _num(b))) throw Refused('§58: деление вне таблицы делимых');
+    if (_u(b) == BigInt.zero) throw Refused('деление на ноль — evaluation error (§58)');
+    Money? like;
+    if (a is Money && b is Money) {
+      if (a.cur != b.cur) {
+        throw Refused('CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте');
+      }
+    } else if (a is Money) {
+      like = a;
+    } else if (b is Money) {
+      throw Refused('§58: деление вне таблицы делимых');
+    }
+    final q = _exact(_u(a) * _p10(_s(b)), _u(b) * _p10(_s(a)));
+    if (q == null) {
+      if (like != null) throw Refused('INEXACT_DIVISION: округление только явной политикой (§50/§18)');
+      throw Refused('§58: частное не 10-гладкое — Rational вне среза');
+    }
+    return like == null ? Dec(q[0] as BigInt, q[1] as int) : Money(q[0] as BigInt, q[1] as int, like.cur);
+  }
+
+  // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+  static Object mod(Object a, Object b) {
+    if (!(_integral(a) && _integral(b))) throw Refused('§58: mod определён только для Integer');
+    final y = _toInt(b as Dec);
+    if (y == BigInt.zero) throw Refused('остаток от деления на ноль — evaluation error (§58)');
+    return Dec(_toInt(a as Dec) % y.abs(), 0);
+  }
+
+  static Object min(Object a, Object b) {
+    _same(a, b, 'min');
+    final p = _pair(a, b);
+    return (p[0] as BigInt) <= (p[1] as BigInt) ? a : b;
+  }
+
+  static Object max(Object a, Object b) {
+    _same(a, b, 'max');
+    final p = _pair(a, b);
+    return (p[0] as BigInt) >= (p[1] as BigInt) ? a : b;
+  }
+
+  static Object abs(Object v) {
+    if (!_num(v)) throw Refused('§58: abs — не числовой вид');
+    return _make(_u(v).abs(), _s(v), v);
+  }
+
+  static final BigInt _powMin = -(BigInt.one << 63);
+  static final BigInt _powMax = (BigInt.one << 63) - BigInt.one;
+
+  // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+  // вычисление, диапазон — часть контракта.
+  static Object pow(Object base, Object exp) {
+    if (!(_integral(base) && _integral(exp))) throw Refused('§58: pow определён только для Integer');
+    final e = _toInt(exp as Dec);
+    if (e.isNegative) throw Refused('§58: pow — показатель отрицателен');
+    if (e > BigInt.from(4096)) throw Refused('RESOURCE_LIMIT: pow — показатель превышает 4096');
+    final r = _toInt(base as Dec).pow(e.toInt());
+    if (r < _powMin || r > _powMax) throw Refused('RESOURCE_LIMIT: pow — результат вне 64-битного диапазона');
+    return Dec(r, 0);
+  }
+
+  static Object round(Object m, Object digits, String mode) {
+    if (mode != 'HALF_UP') throw Refused('§50: режим округления не реализован: $mode');
+    if (!_num(m)) throw Refused('§50: round — не числовой вид');
+    final n = digits is int ? digits : _toInt(digits as Dec).toInt();
+    if (_s(m) <= n) return _make(_u(m) * _p10(n - _s(m)), n, m);
+    final drop = _p10(_s(m) - n);
+    final a = _u(m).abs();
+    final q = a ~/ drop, r = a.remainder(drop);
+    final up = r * BigInt.two >= drop ? q + BigInt.one : q; // HALF_UP — от нуля
+    return _make(_u(m).isNegative ? -up : up, n, m);
+  }
+
+  static bool _order(String op, int c) {
+    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;
+    }
+    throw Refused('сравнение вне среза рантайма: $op');
+  }
+
+  static bool cmp(Object a, String op, Object b) {
+    if (a is Sym || b is Sym) {
+      final same = a is Sym && b is Sym && a.id == b.id;
+      if (op == 'eq') return same;
+      if (op == 'ne') return !same;
+      throw Refused('§57: вид enum не упорядочен');
+    }
+    if (a is LDate || b is LDate) {
+      if (a is LDate && b is LDate) return _order(op, a.v.compareTo(b.v));
+      if (op == 'eq') return false;
+      if (op == 'ne') return true;
+      throw Refused('§57: Date сравнивается только с Date');
+    }
+    if (a is String || b is String) {
+      if (op == 'eq') return a == b;
+      if (op == 'ne') return a != b;
+      throw Refused('порядок на Text вне среза рантайма: $op');
+    }
+    if ((a is Money) != (b is Money)) throw Refused('§49: сравнение денег с безразмерным');
+    if (a is Money && a.cur != (b as Money).cur) throw Refused('§49: разные валюты');
+    final p = _pair(a, b);
+    return _order(op, (p[0] as BigInt).compareTo(p[1] as BigInt));
+  }
+
+  static bool eq(Object a, Object b) {
+    if (a is Sym || b is Sym) return a is Sym && b is Sym && a.id == b.id;
+    if (a is LDate || b is LDate) return a is LDate && b is LDate && a.v == b.v;
+    if (a is String || b is String) return a == b;
+    if ((a is Money) != (b is Money)) return false;
+    if (a is Money && a.cur != (b as Money).cur) return false;
+    final p = _pair(a, b);
+    return p[0] == p[1];
+  }
+
+  static String _norm(Object d) {
+    var u = _u(d);
+    var s = _s(d);
+    while (s > 0 && u.remainder(_ten) == BigInt.zero) {
+      u = u ~/ _ten;
+      s--;
+    }
+    return '${u}e-$s';
+  }
+
+  // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+  // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+  static String _esc(String text) => text.replaceAll('\\', '\\\\').replaceAll('|', '\\|');
+
+  static String key(List<Object> row) => row.map((v) {
+        if (v is String) return 'e:' + _esc(v);
+        if (v is LDate) return 't:' + v.v;
+        if (v is Sym) return 'c:' + _esc(v.id);
+        if (v is Money) return 'm:' + v.cur + ':' + _norm(v);
+        return 'd:' + _norm(v);
+      }).join('|');
+
+  static String _legalTime = '';
+
+  static void setLegalTime(String t) {
+    _legalTime = t;
+  }
+
+  static String legalTime() {
+    if (_legalTime.isEmpty) throw Refused('legalTime не подан делом');
+    return _legalTime;
+  }
+}

arxo_codegen/targets/erl/cert.erl

@@ -0,0 +1,64 @@
+%% Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+%% что получилось. Ожидания сверяют ворота, харнесс их не читает.
+-module(cert).
+-export([main/1]).
+
+lit(X) when is_binary(X) -> unicode:characters_to_list(X);
+lit(#{<<"dec">> := D}) -> rt:dec(D);
+lit(#{<<"money">> := M, <<"cur">> := C}) -> rt:money(M, C);
+lit(#{<<"text">> := T}) -> {text, T};
+lit(#{<<"date">> := D}) -> rt:date(D);
+lit(#{<<"sym">> := S}) -> rt:sym(S);
+lit(#{<<"row">> := R}) -> [lit(V) || V <- R].
+
+%% Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+digits(U, S) ->
+    Body0 = integer_to_list(erlang:abs(U)),
+    Body = lists:duplicate(erlang:max(0, S + 1 - length(Body0)), $0) ++ Body0,
+    Text = case S of
+        0 -> Body;
+        _ -> {I, F} = lists:split(length(Body) - S, Body), I ++ "." ++ F
+    end,
+    unicode:characters_to_binary(case U < 0 of true -> "-" ++ Text; false -> Text end).
+
+render(null) -> null;
+render(B) when is_boolean(B) -> B;
+render({text, T}) -> T;
+render({money, U, S, C}) -> <<(digits(U, S))/binary, " ", C/binary>>;
+render({date, D}) -> D;
+render({sym, I}) -> I;
+render({dec, U, S}) -> digits(U, S).
+
+run(#{<<"op">> := Op, <<"args">> := Raw}) ->
+    A = [lit(X) || X <- Raw],
+    case Op of
+        <<"dec">> -> rt:dec(hd(A));
+        <<"money">> -> rt:money(hd(A), lists:nth(2, A));
+        <<"date">> -> rt:date(hd(A));
+        <<"sym">> -> rt:sym(hd(A));
+        <<"add">> -> rt:add(hd(A), lists:nth(2, A));
+        <<"sub">> -> rt:sub(hd(A), lists:nth(2, A));
+        <<"mul">> -> rt:mul(hd(A), lists:nth(2, A));
+        <<"div">> -> rt:'div'(hd(A), lists:nth(2, A));
+        <<"mod">> -> rt:'mod'(hd(A), lists:nth(2, A));
+        <<"min">> -> rt:min(hd(A), lists:nth(2, A));
+        <<"max">> -> rt:max(hd(A), lists:nth(2, A));
+        <<"abs">> -> rt:'abs'(hd(A));
+        <<"pow">> -> rt:pow(hd(A), lists:nth(2, A));
+        <<"round">> -> rt:round(hd(A), lists:nth(2, A), lists:nth(3, A));
+        <<"cmp">> -> rt:cmp(hd(A), lists:nth(2, A), lists:nth(3, A));
+        <<"eq">> -> rt:eq(hd(A), lists:nth(2, A));
+        <<"keyEq">> -> rt:key(hd(A)) =:= rt:key(lists:nth(2, A));
+        <<"legalTime">> -> {text, rt:legal_time()};
+        <<"setLegalTime">> -> rt:set_legal_time(hd(A)), null
+    end.
+
+main([Path]) ->
+    {ok, Bin} = file:read_file(Path),
+    #{<<"cases">> := Cases} = json:decode(Bin),
+    Out = [begin
+        Got = try render(run(C)) catch throw:{refused, Msg} -> #{<<"refused">> => Msg} end,
+        #{<<"id">> => maps:get(<<"id">>, C), <<"got">> => Got}
+    end || C <- Cases],
+    io:format("~ts~n", [json:encode(Out)]),
+    erlang:halt(0).