arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/java/Cert.java

@@ -0,0 +1,91 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public final class Cert {
+    static Object lit(Object x) {
+        if (x instanceof String) return x;
+        Map<String, Object> m = Json.obj(x);
+        if (m.containsKey("dec")) return Runtime.dec(Json.str(m.get("dec")));
+        if (m.containsKey("money")) return Runtime.money(Json.str(m.get("money")), Json.str(m.get("cur")));
+        if (m.containsKey("text")) return Json.str(m.get("text"));
+        if (m.containsKey("date")) return Runtime.date(Json.str(m.get("date")));
+        if (m.containsKey("sym")) return Runtime.sym(Json.str(m.get("sym")));
+        if (m.containsKey("row")) { List<Object> r = new ArrayList<>(); for (Object v : Json.arr(m.get("row"))) r.add(lit(v)); return r; }
+        throw new IllegalArgumentException("литерал фикстуры: " + x);
+    }
+
+    // Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+    static String digits(BigInteger u, int s) {
+        boolean neg = u.signum() < 0;
+        StringBuilder body = new StringBuilder(u.abs().toString());
+        while (body.length() < s + 1) body.insert(0, '0');
+        String text = s == 0 ? body.toString() : body.substring(0, body.length() - s) + "." + body.substring(body.length() - s);
+        return (neg ? "-" : "") + text;
+    }
+
+    static Object render(Object v) {
+        if (v == null || v instanceof Boolean || v instanceof String) return v;
+        if (v instanceof Runtime.Money) { Runtime.Money m = (Runtime.Money) v; return digits(m.u, m.s) + " " + m.cur; }
+        if (v instanceof Runtime.Date) return ((Runtime.Date) v).v;
+        if (v instanceof Runtime.Sym) return ((Runtime.Sym) v).id;
+        Runtime.Dec d = (Runtime.Dec) v;
+        return digits(d.u, d.s);
+    }
+
+    @SuppressWarnings("unchecked")
+    static Object run(Map<String, Object> c) {
+        List<Object> a = new ArrayList<>();
+        for (Object x : Json.arr(c.get("args"))) a.add(lit(x));
+        switch (Json.str(c.get("op"))) {
+            case "dec": return Runtime.dec((String) a.get(0));
+            case "money": return Runtime.money((String) a.get(0), (String) a.get(1));
+            case "date": return Runtime.date((String) a.get(0));
+            case "sym": return Runtime.sym((String) a.get(0));
+            case "add": return Runtime.add(a.get(0), a.get(1));
+            case "sub": return Runtime.sub(a.get(0), a.get(1));
+            case "mul": return Runtime.mul(a.get(0), a.get(1));
+            case "div": return Runtime.div(a.get(0), a.get(1));
+            case "mod": return Runtime.mod(a.get(0), a.get(1));
+            case "min": return Runtime.min(a.get(0), a.get(1));
+            case "max": return Runtime.max(a.get(0), a.get(1));
+            case "abs": return Runtime.abs(a.get(0));
+            case "pow": return Runtime.pow(a.get(0), a.get(1));
+            case "round": return Runtime.round(a.get(0), a.get(1), (String) a.get(2));
+            case "cmp": return Runtime.cmp(a.get(0), (String) a.get(1), a.get(2));
+            case "eq": return Runtime.eq(a.get(0), a.get(1));
+            case "keyEq": return Runtime.key((List<Object>) a.get(0)).equals(Runtime.key((List<Object>) a.get(1)));
+            case "legalTime": return Runtime.legalTime();
+            case "setLegalTime": Runtime.setLegalTime((String) a.get(0)); return null;
+            default: throw new IllegalArgumentException("неизвестная операция фикстуры: " + c.get("op"));
+        }
+    }
+
+    public static void main(String[] argv) throws Exception {
+        Map<String, Object> fixture = Json.obj(Json.parse(Files.readString(Path.of(argv[0]), StandardCharsets.UTF_8)));
+        List<Object> out = new ArrayList<>();
+        for (Object c : Json.arr(fixture.get("cases"))) {
+            Map<String, Object> cm = Json.obj(c);
+            Object got;
+            try {
+                got = render(run(cm));
+            } catch (Runtime.Refused e) {
+                Map<String, Object> r = new LinkedHashMap<>();
+                r.put("refused", e.getMessage());
+                got = r;
+            }
+            Map<String, Object> row = new LinkedHashMap<>();
+            row.put("id", cm.get("id"));
+            row.put("got", got);
+            out.add(row);
+        }
+        System.out.println(Json.write(out));
+    }
+}

arxo_codegen/targets/java/Json.java

@@ -0,0 +1,148 @@
+// Минимальный JSON для раннера и харнесса: в стандартной библиотеке Java его
+// нет. Числа сохраняются ТЕКСТОМ (класс Num) — значение Integer дела не
+// проходит через double. Объекты — LinkedHashMap в порядке документа.
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public final class Json {
+
+    public static final class Num {
+        public final String text;
+        public Num(String t) { text = t; }
+        @Override public String toString() { return text; }
+    }
+
+    private final String s;
+    private int i = 0;
+    private Json(String s) { this.s = s; }
+
+    public static Object parse(String text) {
+        Json p = new Json(text);
+        Object v = p.value();
+        p.ws();
+        if (p.i != p.s.length()) throw new IllegalArgumentException("JSON: хвост после значения");
+        return v;
+    }
+
+    private void ws() { while (i < s.length() && " \t\r\n".indexOf(s.charAt(i)) >= 0) i++; }
+
+    private Object value() {
+        ws();
+        char c = s.charAt(i);
+        if (c == '{') return object();
+        if (c == '[') return array();
+        if (c == '"') return string();
+        if (s.startsWith("true", i)) { i += 4; return Boolean.TRUE; }
+        if (s.startsWith("false", i)) { i += 5; return Boolean.FALSE; }
+        if (s.startsWith("null", i)) { i += 4; return null; }
+        int start = i;
+        while (i < s.length() && "+-0123456789.eE".indexOf(s.charAt(i)) >= 0) i++;
+        if (start == i) throw new IllegalArgumentException("JSON: неожиданный символ " + c);
+        return new Num(s.substring(start, i));
+    }
+
+    private Map<String, Object> object() {
+        Map<String, Object> m = new LinkedHashMap<>();
+        i++;
+        ws();
+        if (s.charAt(i) == '}') { i++; return m; }
+        while (true) {
+            ws();
+            String k = string();
+            ws();
+            if (s.charAt(i) != ':') throw new IllegalArgumentException("JSON: ожидалось ':'");
+            i++;
+            m.put(k, value());
+            ws();
+            char c = s.charAt(i++);
+            if (c == '}') return m;
+            if (c != ',') throw new IllegalArgumentException("JSON: ожидалась ','");
+        }
+    }
+
+    private List<Object> array() {
+        List<Object> a = new ArrayList<>();
+        i++;
+        ws();
+        if (s.charAt(i) == ']') { i++; return a; }
+        while (true) {
+            a.add(value());
+            ws();
+            char c = s.charAt(i++);
+            if (c == ']') return a;
+            if (c != ',') throw new IllegalArgumentException("JSON: ожидалась ','");
+        }
+    }
+
+    private String string() {
+        if (s.charAt(i) != '"') throw new IllegalArgumentException("JSON: ожидалась строка");
+        i++;
+        StringBuilder b = new StringBuilder();
+        while (true) {
+            char c = s.charAt(i++);
+            if (c == '"') return b.toString();
+            if (c != '\\') { b.append(c); continue; }
+            char e = s.charAt(i++);
+            switch (e) {
+                case '"': b.append('"'); break;
+                case '\\': b.append('\\'); break;
+                case '/': b.append('/'); break;
+                case 'b': b.append('\b'); break;
+                case 'f': b.append('\f'); break;
+                case 'n': b.append('\n'); break;
+                case 'r': b.append('\r'); break;
+                case 't': b.append('\t'); break;
+                case 'u': b.append((char) Integer.parseInt(s.substring(i, i + 4), 16)); i += 4; break;
+                default: throw new IllegalArgumentException("JSON: экран \\" + e);
+            }
+        }
+    }
+
+    // --- запись ---------------------------------------------------------------
+    public static String quote(String t) {
+        StringBuilder b = new StringBuilder("\"");
+        for (char c : t.toCharArray()) {
+            switch (c) {
+                case '"': b.append("\\\""); break;
+                case '\\': b.append("\\\\"); break;
+                case '\n': b.append("\\n"); break;
+                case '\r': b.append("\\r"); break;
+                case '\t': b.append("\\t"); break;
+                default:
+                    if (c < 0x20) b.append(String.format("\\u%04x", (int) c)); else b.append(c);
+            }
+        }
+        return b.append('"').toString();
+    }
+
+    @SuppressWarnings("unchecked")
+    public static String write(Object v) {
+        if (v == null) return "null";
+        if (v instanceof Boolean || v instanceof Num) return v.toString();
+        if (v instanceof String) return quote((String) v);
+        if (v instanceof List) {
+            StringBuilder b = new StringBuilder("[");
+            boolean first = true;
+            for (Object x : (List<Object>) v) { if (!first) b.append(','); first = false; b.append(write(x)); }
+            return b.append(']').toString();
+        }
+        if (v instanceof Map) {
+            StringBuilder b = new StringBuilder("{");
+            boolean first = true;
+            for (Map.Entry<String, Object> e : ((Map<String, Object>) v).entrySet()) {
+                if (!first) b.append(','); first = false;
+                b.append(quote(e.getKey())).append(':').append(write(e.getValue()));
+            }
+            return b.append('}').toString();
+        }
+        throw new IllegalArgumentException("JSON: вид " + v.getClass());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static Map<String, Object> obj(Object v) { return (Map<String, Object>) v; }
+    @SuppressWarnings("unchecked")
+    public static List<Object> arr(Object v) { return v == null ? new ArrayList<>() : (List<Object>) v; }
+    public static String str(Object v) { return v == null ? "" : v.toString(); }
+}

arxo_codegen/targets/java/Runner.java

@@ -0,0 +1,151 @@
+// Раннер Java-бэкенда: тот же вход и тот же ответ, что у runner.py.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public final class Runner {
+    static final List<Object> ISSUES = new ArrayList<>();
+
+    static Object arg(Map<String, Object> a) {
+        String kind = Json.str(a.get("kind"));
+        if (kind.equals("entity_ref")) return Json.str(a.get("id"));
+        if (kind.equals("const_ref")) {
+            // §54: разыменование предшествует исполнению; член перечисления §38 либо
+            // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+            Object[] c = Model.CONSTS.get(Json.str(a.get("id")));
+            return c == null ? Runtime.sym(Json.str(a.get("id"))) : c[1];
+        }
+        if (!kind.equals("value")) throw new Runtime.Refused("аргумент вне среза раннера: " + kind);
+        String t = Json.str(Json.obj(a.get("type")).get("name"));
+        String v = Json.str(a.get("value"));
+        switch (t) {
+            case "urn:law:std#Money": return Runtime.money(v, Json.str(a.get("currency")));
+            case "urn:law:std#Decimal":
+            case "urn:law:std#Integer": return Runtime.dec(v);
+            case "urn:law:std#Text": return v;
+            case "urn:law:std#Date": return Runtime.date(v);
+            default: throw new Runtime.Refused("аргумент вне среза раннера: " + t);
+        }
+    }
+
+    // Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+    // константы; entity_ref типа не несёт (как у оракула).
+    static String argType(Map<String, Object> a) {
+        String kind = Json.str(a.get("kind"));
+        if (kind.equals("value")) return Json.str(Json.obj(a.get("type")).get("name"));
+        if (kind.equals("const_ref")) { Object[] c = Model.CONSTS.get(Json.str(a.get("id"))); return c == null ? null : (String) c[0]; }
+        return null;
+    }
+
+    // Совпадение типа с наследованием сущностей вверх от фактического.
+    static boolean conforms(String actual, String expected) {
+        Set<String> seen = new HashSet<>();
+        String cur = actual;
+        while (cur != null && !seen.contains(cur)) {
+            if (cur.equals(expected)) return true;
+            seen.add(cur);
+            cur = Model.BASES.get(cur);
+        }
+        return false;
+    }
+
+    static List<Object> args(Map<String, Object> lit) { return Json.arr(lit.get("args")); }
+
+    // Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+    static boolean wellTyped(Map<String, Object> lit) {
+        String[] params = Model.PARAMS.get(Json.str(lit.get("predicate")));
+        if (params == null) return true;
+        List<Object> as = args(lit);
+        if (as.size() != params.length) { ISSUES.add("TYPE_ERROR"); return false; }
+        for (int i = 0; i < params.length; i++) {
+            String actual = argType(Json.obj(as.get(i)));
+            if (actual != null && !conforms(actual, params[i])) { ISSUES.add("TYPE_ERROR"); return false; }
+        }
+        return true;
+    }
+
+    // Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+    // атома не находит — NEITHER без issue.
+    static boolean queryTyped(Map<String, Object> lit) {
+        String[] params = Model.PARAMS.get(Json.str(lit.get("predicate")));
+        if (params == null) return false;
+        List<Object> as = args(lit);
+        if (as.size() != params.length) return false;
+        for (int i = 0; i < params.length; i++) {
+            String actual = argType(Json.obj(as.get(i)));
+            if (actual != null && !conforms(actual, params[i])) return false;
+        }
+        return true;
+    }
+
+    static boolean keyConflictBlocks(String predicate) {
+        Set<String> tainted = new HashSet<>(Model.keyConflictPredicates());
+        ArrayList<String> waiting = new ArrayList<>(tainted);
+        while (!waiting.isEmpty()) {
+            String source = waiting.remove(waiting.size() - 1);
+            for (String consumer : Model.KEY_READERS.getOrDefault(source, new String[0])) if (tainted.add(consumer)) waiting.add(consumer);
+        }
+        return tainted.contains(predicate);
+    }
+
+    static void run(String casePath, String queryPath) throws Exception {
+        Map<String, Object> kase = Json.obj(Json.parse(Files.readString(Path.of(casePath), StandardCharsets.UTF_8)));
+        Map<String, Object> query = Json.obj(Json.parse(Files.readString(Path.of(queryPath), StandardCharsets.UTF_8)));
+        Map<String, Object> ctx = kase.get("context") == null ? new LinkedHashMap<>() : Json.obj(kase.get("context"));
+        Runtime.setLegalTime(Json.str(ctx.get("legalTime")));
+        Model.packageFacts();
+        for (Object a : Json.arr(kase.get("assertions"))) {
+            Map<String, Object> lit = Json.obj(Json.obj(a).get("literal"));
+            if (!"positive".equals(Json.str(lit.get("polarity")))) throw new Runtime.Refused("§113: отрицательный факт вне L0-среза");
+            if (!wellTyped(lit)) continue;
+            String pred = Json.str(lit.get("predicate"));
+            if (!Model.PARAMS.containsKey(pred)) continue;
+            List<Object> row = new ArrayList<>();
+            for (Object x : args(lit)) row.add(arg(Json.obj(x)));
+            Model.register(pred, row);
+        }
+        Model.saturate();
+        for (int n = Model.keyConflicts(); n > 0; n--) ISSUES.add("KEY_CONFLICT");
+        if (!"truth".equals(Json.str(query.get("kind")))) throw new Runtime.Refused("вид запроса вне среза раннера: " + Json.str(query.get("kind")));
+        Map<String, Object> lit = Json.obj(query.get("literal"));
+        boolean hit = false;
+        if (queryTyped(lit)) {
+            List<Object> want = new ArrayList<>();
+            for (Object x : args(lit)) want.add(arg(Json.obj(x)));
+            List<List<Object>> rows = Model.TABLES.getOrDefault(Json.str(lit.get("predicate")), new ArrayList<>());
+            for (List<Object> r : rows) {
+                if (r.size() != want.size()) continue;
+                boolean all = true;
+                for (int i = 0; i < r.size(); i++) if (!Runtime.eq(r.get(i), want.get(i))) { all = false; break; }
+                if (all) { hit = true; break; }
+            }
+        }
+        // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+        Map<String, Object> out = new LinkedHashMap<>();
+        out.put("queryId", query.get("queryId"));
+        out.put("truthStatus", hit ? "TRUE_ONLY" : "NEITHER");
+        out.put("evaluationStatus", keyConflictBlocks(Json.str(lit.get("predicate"))) ? "NON_EXECUTABLE" : "COMPUTED");
+        out.put("issues", ISSUES);
+        System.out.println(Json.write(out));
+    }
+
+    public static void main(String[] argv) throws Exception {
+        try {
+            run(argv[0], argv[1]);
+        } catch (Runtime.Refused e) {
+            Map<String, Object> out = new LinkedHashMap<>();
+            out.put("refused", e.getMessage());
+            System.out.println(Json.write(out));
+            System.exit(3);
+        }
+    }
+}

arxo_codegen/targets/java/Runtime.java

@@ -0,0 +1,243 @@
+// Рантайм L0 для Java. Тот же контракт, что у runtime.py: точная десятичная
+// арифметика §58 на BigInteger, деньги с валютой, названный режим округления,
+// календарный день, член перечисления. Отказ — исключение Refused; любое другое
+// исключение — крах.
+import java.math.BigInteger;
+import java.util.List;
+import java.util.ArrayList;
+
+public final class Runtime {
+    private Runtime() {}
+
+    public static final class Refused extends RuntimeException {
+        public Refused(String m) { super(m); }
+    }
+
+    public static class Dec {
+        public final BigInteger u; public final int s;
+        public Dec(BigInteger u, int s) { this.u = u; this.s = s; }
+    }
+    public static final class Money extends Dec {
+        public final String cur;
+        public Money(BigInteger u, int s, String cur) { super(u, s); this.cur = cur; }
+    }
+    // Календарный день §2.15 в канонической записи ISO YYYY-MM-DD.
+    public static final class Date { public final String v; public Date(String v) { this.v = v; } }
+    // Член перечисления §38 либо ссылка const_ref без объявления.
+    public static final class Sym { public final String id; public Sym(String id) { this.id = id; } }
+
+    private static BigInteger p10(int n) { return BigInteger.TEN.pow(n); }
+
+    public static Dec dec(String lit) {
+        int dot = lit.indexOf('.');
+        String i = dot < 0 ? lit : lit.substring(0, dot);
+        String f = dot < 0 ? "" : lit.substring(dot + 1);
+        boolean neg = i.startsWith("-");
+        String digits = (neg ? i.substring(1) : i) + f;
+        BigInteger u = new BigInteger(digits);
+        return new Dec(neg ? u.negate() : u, f.length());
+    }
+    public static Money money(String lit, String cur) { Dec d = dec(lit); return new Money(d.u, d.s, cur); }
+    public static Date date(String lit) { return new Date(lit); }
+    public static Sym sym(String id) { return new Sym(id); }
+
+    // --- виды ---------------------------------------------------------------
+    private static boolean isNum(Object v) { return v instanceof Dec; }
+    private static boolean isMoney(Object v) { return v instanceof Money; }
+
+    // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+    private static void same(Object a, Object b, String op) {
+        if (!isNum(a) || !isNum(b) || isMoney(a) != isMoney(b)) throw new Refused("§58: виды операндов не совпадают: " + op);
+        if (isMoney(a) && !((Money) a).cur.equals(((Money) b).cur)) throw new Refused("§58: разные валюты: " + op);
+    }
+    private static BigInteger[] pair(Dec a, Dec b) {
+        int s = Math.max(a.s, b.s);
+        return new BigInteger[]{a.u.multiply(p10(s - a.s)), b.u.multiply(p10(s - b.s)), BigInteger.valueOf(s)};
+    }
+    private static Dec mk(BigInteger u, int s, Object like) {
+        return isMoney(like) ? new Money(u, s, ((Money) like).cur) : new Dec(u, s);
+    }
+    // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+    private static BigInteger integral(Object v) {
+        if (!(v instanceof Dec) || v instanceof Money) return null;
+        Dec d = (Dec) v;
+        BigInteger[] qr = d.u.divideAndRemainder(p10(d.s));
+        return qr[1].signum() == 0 ? qr[0] : null;
+    }
+
+    // --- арифметика §58 -----------------------------------------------------
+    public static Dec add(Object a, Object b) { same(a, b, "add"); BigInteger[] p = pair((Dec) a, (Dec) b); return mk(p[0].add(p[1]), p[2].intValue(), a); }
+    public static Dec sub(Object a, Object b) { same(a, b, "sub"); BigInteger[] p = pair((Dec) a, (Dec) b); return mk(p[0].subtract(p[1]), p[2].intValue(), a); }
+
+    // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+    // сумма масштабов. Два размерных не перемножаются.
+    public static Dec mul(Object a, Object b) {
+        if (!isNum(a) || !isNum(b)) throw new Refused("§58: виды операндов не совпадают: mul");
+        if (isMoney(a) && isMoney(b)) throw new Refused("§58: произведение двух размерных величин не определено");
+        Dec x = (Dec) a, y = (Dec) b;
+        return mk(x.u.multiply(y.u), x.s + y.s, isMoney(a) ? a : b);
+    }
+
+    // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе null.
+    private static Object[] exact(BigInteger num, BigInteger den) {
+        BigInteger g = num.gcd(den);
+        if (g.signum() == 0) g = BigInteger.ONE;
+        num = num.divide(g); den = den.divide(g);
+        if (den.signum() < 0) { num = num.negate(); den = den.negate(); }
+        BigInteger two = BigInteger.TWO, five = BigInteger.valueOf(5);
+        int twos = 0, fives = 0;
+        while (den.mod(two).signum() == 0) { den = den.divide(two); twos++; }
+        while (den.mod(five).signum() == 0) { den = den.divide(five); fives++; }
+        if (!den.equals(BigInteger.ONE)) return null;
+        int k = Math.max(twos, fives);
+        return new Object[]{num.multiply(two.pow(k - twos)).multiply(five.pow(k - fives)), k};
+    }
+
+    // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+    // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+    public static Dec div(Object a, Object b) {
+        if (!isNum(a) || !isNum(b)) throw new Refused("§58: деление вне таблицы делимых");
+        Dec x = (Dec) a, y = (Dec) b;
+        if (y.u.signum() == 0) throw new Refused("деление на ноль — evaluation error (§58)");
+        Money like = null;
+        if (isMoney(a) && isMoney(b)) {
+            if (!((Money) a).cur.equals(((Money) b).cur)) throw new Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте");
+        } else if (isMoney(a)) {
+            like = (Money) a;
+        } else if (isMoney(b)) {
+            throw new Refused("§58: деление вне таблицы делимых");
+        }
+        Object[] q = exact(x.u.multiply(p10(y.s)), y.u.multiply(p10(x.s)));
+        if (q == null) {
+            if (like != null) throw new Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)");
+            throw new Refused("§58: частное не 10-гладкое — Rational вне среза");
+        }
+        return like != null ? new Money((BigInteger) q[0], (Integer) q[1], like.cur) : new Dec((BigInteger) q[0], (Integer) q[1]);
+    }
+
+    // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+    public static Dec mod(Object a, Object b) {
+        BigInteger x = integral(a), y = integral(b);
+        if (x == null || y == null) throw new Refused("§58: mod определён только для Integer");
+        if (y.signum() == 0) throw new Refused("остаток от деления на ноль — evaluation error (§58)");
+        return new Dec(x.mod(y.abs()), 0); // BigInteger.mod — неотрицательный остаток
+    }
+
+    public static Dec min(Object a, Object b) { same(a, b, "min"); BigInteger[] p = pair((Dec) a, (Dec) b); return p[0].compareTo(p[1]) <= 0 ? (Dec) a : (Dec) b; }
+    public static Dec max(Object a, Object b) { same(a, b, "max"); BigInteger[] p = pair((Dec) a, (Dec) b); return p[0].compareTo(p[1]) >= 0 ? (Dec) a : (Dec) b; }
+
+    public static Dec abs(Object v) {
+        if (!isNum(v)) throw new Refused("§58: abs — не числовой вид");
+        Dec d = (Dec) v;
+        return mk(d.u.abs(), d.s, v);
+    }
+
+    private static final BigInteger POW_MIN = BigInteger.valueOf(Long.MIN_VALUE);
+    private static final BigInteger POW_MAX = BigInteger.valueOf(Long.MAX_VALUE);
+
+    // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+    // вычисление, диапазон — часть контракта.
+    public static Dec pow(Object base, Object exp) {
+        BigInteger x = integral(base), e = integral(exp);
+        if (x == null || e == null) throw new Refused("§58: pow определён только для Integer");
+        if (e.signum() < 0) throw new Refused("§58: pow — показатель отрицателен");
+        if (e.compareTo(BigInteger.valueOf(4096)) > 0) throw new Refused("RESOURCE_LIMIT: pow — показатель превышает 4096");
+        BigInteger r = x.pow(e.intValue());
+        if (r.compareTo(POW_MIN) < 0 || r.compareTo(POW_MAX) > 0) throw new Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+        return new Dec(r, 0);
+    }
+
+    public static Dec round(Object m, Object digits, String mode) {
+        if (!mode.equals("HALF_UP")) throw new Refused("§50: режим округления не реализован: " + mode);
+        if (!isNum(m)) throw new Refused("§50: round — не числовой вид");
+        Dec x = (Dec) m;
+        int n = 0;
+        if (digits instanceof Dec) { Dec d = (Dec) digits; n = d.u.divide(p10(d.s)).intValue(); }
+        if (x.s <= n) return mk(x.u.multiply(p10(n - x.s)), n, m);
+        BigInteger drop = p10(x.s - n);
+        boolean neg = x.u.signum() < 0;
+        BigInteger[] qr = x.u.abs().divideAndRemainder(drop);
+        BigInteger up = qr[1].shiftLeft(1).compareTo(drop) >= 0 ? qr[0].add(BigInteger.ONE) : qr[0]; // HALF_UP — от нуля
+        return mk(neg ? up.negate() : up, n, m);
+    }
+
+    // --- сравнение и равенство -----------------------------------------------
+    private static boolean ordered(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;
+            default: throw new Refused("сравнение вне среза рантайма: " + op);
+        }
+    }
+
+    public static boolean cmp(Object a, String op, Object b) {
+        if (a instanceof Sym || b instanceof Sym) {
+            boolean same = a instanceof Sym && b instanceof Sym && ((Sym) a).id.equals(((Sym) b).id);
+            if (op.equals("eq")) return same;
+            if (op.equals("ne")) return !same;
+            throw new Refused("§57: вид enum не упорядочен");
+        }
+        if (a instanceof Date || b instanceof Date) {
+            if (a instanceof Date && b instanceof Date) return ordered(op, ((Date) a).v.compareTo(((Date) b).v));
+            if (op.equals("eq")) return false;
+            if (op.equals("ne")) return true;
+            throw new Refused("§57: Date сравнивается только с Date");
+        }
+        if (a instanceof String || b instanceof String) {
+            boolean same = a instanceof String && b instanceof String && a.equals(b);
+            if (op.equals("eq")) return same;
+            if (op.equals("ne")) return !same;
+            throw new Refused("порядок на Text вне среза рантайма: " + op);
+        }
+        if (isMoney(a) != isMoney(b)) throw new Refused("§49: сравнение денег с безразмерным");
+        if (isMoney(a) && !((Money) a).cur.equals(((Money) b).cur)) throw new Refused("§49: разные валюты");
+        BigInteger[] p = pair((Dec) a, (Dec) b);
+        return ordered(op, p[0].compareTo(p[1]));
+    }
+
+    public static boolean eq(Object a, Object b) {
+        if (a instanceof Sym || b instanceof Sym) return a instanceof Sym && b instanceof Sym && ((Sym) a).id.equals(((Sym) b).id);
+        if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && ((Date) a).v.equals(((Date) b).v);
+        if (a instanceof String || b instanceof String) return a instanceof String && b instanceof String && a.equals(b);
+        if (isMoney(a) != isMoney(b)) return false;
+        if (isMoney(a) && !((Money) a).cur.equals(((Money) b).cur)) return false;
+        BigInteger[] p = pair((Dec) a, (Dec) b);
+        return p[0].equals(p[1]);
+    }
+
+    private static String norm(Dec d) {
+        BigInteger u = d.u; int s = d.s;
+        while (s > 0 && u.mod(BigInteger.TEN).signum() == 0) { u = u.divide(BigInteger.TEN); s--; }
+        return u + "e-" + s;
+    }
+    // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+    private static String esc(String t) { return t.replace("\\", "\\\\").replace("|", "\\|"); }
+
+    public static String key(List<Object> row) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < row.size(); i++) {
+            if (i > 0) sb.append('|');
+            Object v = row.get(i);
+            if (v instanceof String) sb.append("e:").append(esc((String) v));
+            else if (v instanceof Date) sb.append("t:").append(((Date) v).v);
+            else if (v instanceof Sym) sb.append("c:").append(esc(((Sym) v).id));
+            else if (v instanceof Money) sb.append("m:").append(((Money) v).cur).append(':').append(norm((Money) v));
+            else sb.append("d:").append(norm((Dec) v));
+        }
+        return sb.toString();
+    }
+
+    private static String legalTimeValue = "";
+    public static void setLegalTime(String t) { legalTimeValue = t; }
+    public static String legalTime() {
+        if (legalTimeValue.isEmpty()) throw new Refused("legalTime не подан делом");
+        return legalTimeValue;
+    }
+
+    public static List<Object> row(Object... vs) { List<Object> r = new ArrayList<>(); for (Object v : vs) r.add(v); return r; }
+}