arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/excel_plan.py

@@ -0,0 +1,602 @@
+"""Bounded, acyclic L0 -> scalar spreadsheet formulas.
+
+This is a separate execution profile, not an alternative interpretation of
+the common plan. Rows are finite slots; integers encode decimal coefficients.
+Unsupported structure refuses before export; out-of-domain edits refuse in
+the workbook. The XLSX emitter only serializes this cell plan.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import itertools
+import json
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+
+import plan as P
+
+PROFILE = "excel-calculator/0.1"
+FORMAT = "law.excel-plan/1"
+LIMIT = 10 ** 12
+MAX_SLOTS = 2000
+MAX_CELLS = 100000
+MAX_SCALE = 12
+STD = P.STD
+KINDS = {STD + "Text": "text", STD + "Integer": "dec", STD + "Decimal": "dec",
+         STD + "Money": "money", STD + "Date": "date"}
+EPOCH = dt.date(1899, 12, 30)
+
+
+def refuse(message):
+    raise P.Refused(f"{PROFILE}: {message}")
+
+
+def fields(obj, allowed, where):
+    if not isinstance(obj, dict):
+        refuse(f"{where}: ожидается объект")
+    unknown = set(obj) - set(allowed)
+    if unknown:
+        refuse(f"{where}: неизвестные поля {', '.join(sorted(unknown))}")
+
+
+def col(i):
+    out = ""
+    while i:
+        i, n = divmod(i - 1, 26)
+        out = chr(65 + n) + out
+    return out
+
+
+def quoted(value):
+    return '"' + str(value).replace('"', '""') + '"'
+
+
+def conjunction(items):
+    items = list(items)
+    if not items:
+        return "TRUE()"
+    # Excel permits 255 function arguments. Binary nesting is unnecessary.
+    while len(items) > 100:
+        items = ["AND(" + ",".join(items[i:i + 100]) + ")" for i in range(0, len(items), 100)]
+    return items[0] if len(items) == 1 else "AND(" + ",".join(items) + ")"
+
+
+def date_number(value):
+    try:
+        day = dt.date.fromisoformat(value)
+    except (ValueError, TypeError):
+        refuse(f"неверная дата {value!r}")
+    if day < dt.date(1900, 3, 1):
+        refuse("даты до 1900-03-01 вне профиля (Excel 1900 date system)")
+    return (day - EPOCH).days
+
+
+def decimal_parts(value):
+    try:
+        d = Decimal(str(value))
+        if not d.is_finite() or abs(d) > LIMIT:
+            refuse(f"число вне диапазона: {value!r}")
+        sign, digits, exponent = d.as_tuple()
+        if exponent < -MAX_SCALE or exponent > MAX_SCALE:
+            refuse(f"масштаб числа вне профиля: {value!r}")
+        u, s = int(''.join(map(str, digits))) * (-1 if sign else 1), max(0, -exponent)
+        u *= 10 ** max(0, exponent)
+        while s and u % 10 == 0:
+            u //= 10
+            s -= 1
+        if abs(u) > LIMIT:
+            refuse(f"коэффициент числа вне ±{LIMIT}: {value!r}")
+        return u, s
+    except (InvalidOperation, ValueError):
+        refuse(f"неверное число {value!r}")
+
+
+@dataclass
+class Value:
+    ref: str
+    kind: str
+    scale: int = 0
+    currency: str | None = None
+
+
+@dataclass
+class Row:
+    active: str
+    args: list[Value]
+    source: str
+
+
+class Planner:
+    def __init__(self, plan, config=None):
+        self.plan = plan
+        if config is not None and not isinstance(config, dict):
+            refuse("конфигурация должна быть объектом")
+        self.config = dict(config or {})
+        self.sheets = {n: {"name": n, "cells": [], "validations": [], "warnings": []}
+                       for n in ("Results", "Inputs", "Calculation", "Model")}
+        self.mapping = {"format": "law.excel-cells/1", "profile": PROFILE,
+                        "status": "Results!B3", "legalTime": "Inputs!B4", "inputs": {}, "tables": {}}
+        self.nr = {n: 7 for n in self.sheets}
+        self.cells = 0
+        self.slots = 0
+        self.rows = {}
+        self.input_checks = []
+        self.numeric_currency = self.config.get("currency")
+
+    def put(self, sheet, row, column, value=None, formula=None, style="body"):
+        self.cells += 1
+        if self.cells > MAX_CELLS:
+            refuse(f"более {MAX_CELLS} ячеек; уменьшите число входных строк")
+        if formula and len(formula.encode("utf-16-le")) // 2 > 8000:
+            refuse("формула длиннее 8000 символов; уменьшите число строк")
+        for text in (value, formula):
+            if isinstance(text, str) and (len(text) > 30000 or any(
+                    (ord(c) < 32 and c not in '\t\n\r') or 0xD800 <= ord(c) <= 0xDFFF or ord(c) in (0xFFFE, 0xFFFF) for c in text)):
+                refuse("текст ячейки слишком длинный либо содержит запрещённые XML-символы")
+        address = f"{col(column)}{row}"
+        self.sheets[sheet]["cells"].append({"cell": address, "value": value, "formula": formula, "style": style})
+        return f"'{sheet}'!{address}"
+
+    def helper(self, expression, label, gate="TRUE()", bounded=False):
+        n = self.nr["Calculation"]
+        self.nr["Calculation"] += 1
+        self.put("Calculation", n, 1, label)
+        raw = self.put("Calculation", n, 2, formula=f'IF({gate},{expression},0)')
+        checked = self.put("Calculation", n, 3,
+                           formula=f'IF(ABS({raw})<={LIMIT},{raw},NA())' if bounded else raw)
+        self.put("Calculation", n, 4, formula=f'IF(ISERROR({checked}),1,0)')
+        return checked
+
+    def warning(self, sheet, reference):
+        cell = reference.rsplit("!", 1)[-1]
+        formula = 'OR(' + ','.join(f'{cell}={quoted(status)}' for status in
+                                  ("INVALID_INPUT", "CALCULATION_REFUSED", "KEY_CONFLICT")) + ')'
+        self.sheets[sheet]["warnings"].append({"sqref": cell, "formula": formula})
+
+    def number(self, expr, scale, kind="dec", currency=None, gate="TRUE()", label="Число"):
+        if not 0 <= scale <= MAX_SCALE:
+            refuse(f"масштаб промежуточного значения {scale} вне 0..{MAX_SCALE}")
+        return Value(self.helper(expr, label, gate, bounded=True), kind, scale, currency)
+
+    def rescale(self, value, scale, gate):
+        delta = scale - value.scale
+        if delta == 0:
+            return value
+        if delta > 0:
+            expression = f'{value.ref}*{10 ** delta}'
+        else:
+            d = 10 ** -delta
+            expression = f'IF(MOD({value.ref},{d})=0,ROUND({value.ref}/{d},0),NA())'
+        return self.number(expression, scale, value.kind, value.currency, gate, "Точный масштаб")
+
+    def same_kind(self, a, b):
+        if a.kind != b.kind or a.currency != b.currency:
+            refuse("разные виды или валюты в операции")
+
+    def compare(self, a, b, op, gate):
+        self.same_kind(a, b)
+        if a.kind == "text":
+            if op not in ("eq", "ne"):
+                refuse("порядок на Text вне профиля")
+            expr = f'EXACT({a.ref},{b.ref})'
+            return expr if op == "eq" else f'NOT({expr})'
+        if a.kind in ("money", "dec"):
+            s = max(a.scale, b.scale)
+            a, b = self.rescale(a, s, gate), self.rescale(b, s, gate)
+        operator = {"eq": "=", "ne": "<>", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}.get(op)
+        if not operator:
+            refuse(f"неизвестное сравнение {op}")
+        return f'{a.ref}{operator}{b.ref}'
+
+    def term(self, term, env, gate):
+        k = term.get("k")
+        allowed = {"var": {"k", "row", "col", "t"}, "lit": {"k", "t", "v", "cur"},
+                   "bin": {"k", "op", "l", "r"}, "call": {"k", "fn", "args"}}
+        if k not in allowed:
+            refuse(f"терм {k} вне профиля")
+        fields(term, allowed[k], "терм")
+        if k == "var":
+            try:
+                v = env[term["row"]].args[term["col"]]
+            except (IndexError, KeyError):
+                refuse("ссылка переменной вне аргументов тела")
+            if v.kind != term["t"]:
+                refuse("вид переменной не совпадает с колонкой")
+            return v
+        if k == "lit":
+            kind = term["t"]
+            if kind in ("dec", "money"):
+                u, s = decimal_parts(term["v"])
+                cur = term.get("cur")
+                if kind == "money" and cur != self.numeric_currency:
+                    refuse("валюта литерала не совпадает с currency конфигурации")
+                return Value(str(u), kind, s, cur)
+            if kind == "date":
+                return Value(str(date_number(term["v"])), kind)
+            if kind == "text":
+                return Value(quoted(term["v"]), kind)
+            refuse(f"литерал {kind} вне профиля")
+        if k == "bin":
+            a, b = self.term(term["l"], env, gate), self.term(term["r"], env, gate)
+            if a.kind not in ("dec", "money") or b.kind not in ("dec", "money"):
+                refuse("арифметика над нечисловыми значениями")
+            op = term["op"]
+            if op in ("add", "sub"):
+                self.same_kind(a, b)
+                scale = max(a.scale, b.scale)
+                a, b = self.rescale(a, scale, gate), self.rescale(b, scale, gate)
+                return self.number(f'{a.ref}{"+" if op == "add" else "-"}{b.ref}', scale,
+                                   a.kind, a.currency, gate, op)
+            if op == "mul":
+                if a.kind == b.kind == "money":
+                    refuse("произведение двух Money вне профиля")
+                like = a if a.kind == "money" else b
+                return self.number(f'{a.ref}*{b.ref}', a.scale + b.scale, like.kind, like.currency, gate, "mul")
+            if op == "div":
+                if b.kind == "money":
+                    self.same_kind(a, b)
+                scale = max(6, a.scale - b.scale)
+                numerator = self.number(f'{a.ref}*{10 ** (scale + b.scale - a.scale)}', 0,
+                                        gate=gate, label="Числитель деления")
+                expr = f'IF({b.ref}=0,NA(),IF(MOD({numerator.ref},ABS({b.ref}))=0,ROUND({numerator.ref}/{b.ref},0),NA()))'
+                return self.number(expr, scale, "money" if a.kind == "money" and b.kind != "money" else "dec",
+                                   a.currency if b.kind != "money" else None, gate, "Точное деление")
+            if op == "mod":
+                self.same_kind(a, b)
+                if a.kind != "dec":
+                    refuse("mod требует Integer")
+                a, b = self.rescale(a, 0, gate), self.rescale(b, 0, gate)
+                return self.number(f'IF({b.ref}=0,NA(),MOD({a.ref},ABS({b.ref})))', 0, gate=gate, label="mod")
+            refuse(f"операция {op} вне профиля")
+        fn, args = term["fn"], term["args"]
+        if fn == "round":
+            if len(args) != 3 or args[1].get("k") != "lit" or args[2] != {"k": "lit", "t": "text", "v": "HALF_UP"}:
+                refuse("round требует литерал разрядности и режим HALF_UP")
+            n, ns = decimal_parts(args[1]["v"])
+            if ns or not 0 <= n <= 6:
+                refuse("round: разрядность вне 0..6")
+            a = self.term(args[0], env, gate)
+            if a.kind not in ("dec", "money"):
+                refuse("round требует числовое значение")
+            if n >= a.scale:
+                return self.rescale(a, n, gate)
+            drop = 10 ** (a.scale - n)
+            # Integer remainder determines HALF_UP, including negative ties.
+            q = self.helper(f'QUOTIENT(ABS({a.ref}),{drop})', "Целая часть округления", gate)
+            expr = f'SIGN({a.ref})*({q}+IF(MOD(ABS({a.ref}),{drop})*2>={drop},1,0))'
+            return self.number(expr, n, a.kind, a.currency, gate, "HALF_UP")
+        vals = [self.term(a, env, gate) for a in args]
+        if fn == "abs" and len(vals) == 1 and vals[0].kind in ("dec", "money"):
+            a = vals[0]
+            return self.number(f'ABS({a.ref})', a.scale, a.kind, a.currency, gate, fn)
+        if fn in ("min", "max") and len(vals) == 2:
+            a, b = vals
+            self.same_kind(a, b)
+            if a.kind not in ("dec", "money"):
+                refuse(f"{fn} требует числовые значения")
+            s = max(a.scale, b.scale)
+            a, b = self.rescale(a, s, gate), self.rescale(b, s, gate)
+            return self.number(f'{fn.upper()}({a.ref},{b.ref})', s, a.kind, a.currency, gate, fn)
+        refuse(f"функция {fn} вне профиля")
+
+    def validate(self):
+        p, c = self.plan, self.config
+        fields(p, {"planVersion", "package", "world", "tables", "rules", "facts", "excluded", "consts", "bases", "api"}, "план")
+        if p.get("planVersion") != P.PLAN_VERSION:
+            refuse(f"поддержан только {P.PLAN_VERSION}")
+        fields(c, {"profile", "currency", "legalTime", "tables", "semanticHash"}, "конфигурация")
+        if c.get("profile", PROFILE) != PROFILE:
+            refuse("неизвестная версия конфигурации")
+        if self.numeric_currency is not None and (not isinstance(self.numeric_currency, str) or len(self.numeric_currency) != 3):
+            refuse("currency: требуется трёхбуквенный код")
+        self.tables = {t["pred"]: t for t in p["tables"]}
+        if len(self.tables) != len(p["tables"]):
+            refuse("повтор предиката")
+        settings = c.get("tables", {})
+        fields(settings, self.tables, "tables конфигурации")
+        self.settings = {}
+        heads = {r["head"]["pred"] for r in p["rules"]}
+        facts = {f["pred"] for f in p["facts"]}
+        for pred, t in self.tables.items():
+            fields(t, {"pred", "name", "arity", "params", "keys", "kinds"}, pred)
+            if not 0 <= t["arity"] <= 10 or len(t["params"]) != t["arity"] or len(t["kinds"]) != t["arity"]:
+                refuse(f"{pred}: арность вне 0..10 или не совпадает с колонками")
+            for typ, kind in zip(t["params"], t["kinds"]):
+                if KINDS.get(typ) != kind:
+                    refuse(f"{pred}: тип {typ} вне профиля")
+                if kind == "money" and not self.numeric_currency:
+                    refuse("Money требует явного currency конфигурации")
+            fields(settings.get(pred, {}), {"rows", "values", "scales", "columns", "label"}, pred + " config")
+            s = dict(settings.get(pred, {}))
+            fields(s, {"rows", "values", "scales", "columns", "label"}, pred + " config")
+            capacity = s.get("rows", 0 if pred in heads | facts else 1)
+            if type(capacity) is not int or not 0 <= capacity <= 100:
+                refuse(f"{pred}: rows вне 0..100")
+            if pred == P.ALWAYS and capacity:
+                refuse("служебное отношение always не является входом")
+            scales = s.get("scales", [0 if typ != STD + "Decimal" and typ != STD + "Money" else
+                                      2 if typ == STD + "Money" else 4 for typ in t["params"]])
+            if not isinstance(scales, list) or len(scales) != t["arity"] or any(type(n) is not int or not 0 <= n <= 6 for n in scales):
+                refuse(f"{pred}: scales — по одному целому 0..6 на колонку")
+            for typ, scale in zip(t["params"], scales):
+                if typ not in (STD + "Decimal", STD + "Money") and scale:
+                    refuse(f"{pred}: масштаб допустим только для Decimal/Money")
+            columns = s.get("columns", [f'Аргумент {i + 1} ({typ.split("#")[-1]})' for i, typ in enumerate(t["params"])])
+            values = s.get("values", [])
+            if not isinstance(columns, list) or any(not isinstance(x, str) for x in columns) or \
+                    not isinstance(values, list) or len(columns) != t["arity"] or len(values) > capacity or \
+                    any(not isinstance(r, list) or len(r) != t["arity"] for r in values):
+                refuse(f"{pred}: columns/values не совпадают с арностью или rows")
+            if not isinstance(s.get("label", t["name"]), str):
+                refuse(f"{pred}: label должна быть строкой")
+            self.settings[pred] = dict(s, rows=capacity, scales=scales, columns=columns, values=values,
+                                       label=s.get("label", t["name"]))
+        deps = {p: set() for p in self.tables}
+        for r in p["rules"]:
+            fields(r, {"name", "id", "window", "atoms", "joins", "filters", "guards", "head"}, "правило")
+            fields(r["head"], {"pred", "args"}, "голова")
+            if r["head"]["pred"] not in deps:
+                refuse("необъявленная голова правила")
+            for a in r["atoms"]:
+                fields(a, {"pred"}, "атом")
+                if a["pred"] not in deps:
+                    refuse("необъявленный предикат тела")
+                deps[r["head"]["pred"]].add(a["pred"])
+            if len(r["head"]["args"]) != self.tables[r["head"]["pred"]]["arity"]:
+                refuse("арность головы не совпадает с объявлением")
+            if r["window"]:
+                fields(r["window"], {"start", "end"}, "окно")
+                for v in r["window"].values():
+                    if v is not None:
+                        date_number(v)
+        self.order = []
+        while deps:
+            ready = sorted(k for k, reads in deps.items() if not reads)
+            if not ready:
+                refuse("рекурсивные зависимости предикатов вне профиля")
+            self.order.extend(ready)
+            deps = {k: reads - set(ready) for k, reads in deps.items() if k not in ready}
+        # Reject unsupported terms even in rules with no potential rows.
+        for r in p["rules"]:
+            dummy = [Row("FALSE()", [Value("0", k, self.settings[a["pred"]]["scales"][i],
+                          self.numeric_currency if k == "money" else None)
+                          for i, k in enumerate(self.tables[a["pred"]]["kinds"])], "") for a in r["atoms"]]
+            args = [self.term(term, dummy, "FALSE()") for term in r["head"]["args"]]
+            self.normalize(r["head"]["pred"], args, "FALSE()", "проверка головы")
+            for g in r["guards"]:
+                fields(g, {"op", "l", "r"}, "гард")
+                self.compare(self.term(g["l"], dummy, "FALSE()"), self.term(g["r"], dummy, "FALSE()"), g["op"], "FALSE()")
+            for f in r["filters"]:
+                fields(f, {"row", "col", "t", "term"}, "фильтр")
+                if f.get("t") != dummy[f["row"]].args[f["col"]].kind:
+                    refuse("вид фильтра не совпадает с колонкой")
+                self.compare(dummy[f["row"]].args[f["col"]], self.term(f["term"], dummy, "FALSE()"), "eq", "FALSE()")
+        for fact in p["facts"]:
+            fields(fact, {"pred", "args"}, "факт")
+            if fact["pred"] not in self.tables:
+                refuse("факт необъявленного предиката")
+            self.normalize(fact["pred"], [self.term(a, [], "FALSE()") for a in fact["args"]], "FALSE()", "проверка факта")
+        # Validation must not leave unreachable calculation cells behind.
+        self.sheets["Calculation"]["cells"].clear()
+        self.nr["Calculation"] = 7
+        self.cells = 0
+
+    def input_value(self, value, kind, scale):
+        if value is None:
+            return None
+        if kind == "text":
+            if not isinstance(value, str):
+                refuse("Text: начальное значение не строка")
+            return value
+        if kind == "date":
+            return date_number(value)
+        u, s = decimal_parts(value)
+        if s > scale or abs(u) * 10 ** (scale - s) > LIMIT:
+            refuse("начальное значение вне scales/диапазона входной колонки")
+        return float(Decimal(str(value))) if scale else int(Decimal(str(value)))
+
+    def input_rows(self, pred):
+        t, s = self.tables[pred], self.settings[pred]
+        result, mapped = [], []
+        if not s["rows"]:
+            return result
+        n = self.nr["Inputs"]
+        self.put("Inputs", n, 1, s["label"], style="title")
+        for j, v in enumerate(["Включить (0/1)", "Строка"] + s["columns"]):
+            self.put("Inputs", n + 1, j + 1, v, style="header")
+        self.put("Inputs", n + 1, t["arity"] + 3, "Состояние", style="header")
+        for i in range(s["rows"]):
+            n += 1
+            rownum = n + 1
+            initial = s["values"][i] if i < len(s["values"]) else None
+            enable = self.put("Inputs", rownum, 1, 1 if initial is not None else 0, style="input0")
+            self.put("Inputs", rownum, 2, i + 1)
+            args, validations, refs = [], [], []
+            for j, (kind, scale) in enumerate(zip(t["kinds"], s["scales"])):
+                raw = self.put("Inputs", rownum, j + 3,
+                               self.input_value(initial[j], kind, scale) if initial else None,
+                               style="inputdate" if kind == "date" else f"input{scale}" if kind in ("dec", "money") else "inputtext")
+                refs.append(raw.replace("'", ""))
+                if kind == "text":
+                    valid = f'AND(ISTEXT({raw}),LEN({raw})>0,LEN({raw})<=1000)'
+                    expression = raw
+                elif kind == "date":
+                    valid = f'AND(ISNUMBER({raw}),{raw}>=61,{raw}<=2958465,{raw}=INT({raw}))'
+                    expression = raw
+                else:
+                    valid = f'AND(ISNUMBER({raw}),ABS({raw})<={LIMIT / 10 ** scale:g},{raw}=ROUND({raw},{scale}))'
+                    expression = f'ROUND({raw}*{10 ** scale},0)'
+                validations.append(f'IFERROR({valid},FALSE())')
+                local_valid = valid.replace("'Inputs'!", "")
+                self.sheets["Inputs"]["validations"].append({"sqref": f'{col(j + 3)}{rownum}', "formula": f'IFERROR({local_valid},FALSE())'})
+                gate = f'AND({enable}=1,IFERROR({valid},FALSE()))'
+                args.append(Value(self.helper(expression, s["columns"][j], gate), kind, scale,
+                                  self.numeric_currency if kind == "money" else None))
+            valid = conjunction(validations)
+            state = self.put("Inputs", rownum, t["arity"] + 3,
+                             formula=f'IFERROR(IF(AND(ISNUMBER({enable}),{enable}=0),"OFF",IF(AND(ISNUMBER({enable}),{enable}=1,{valid}),"READY","INVALID_INPUT")),"INVALID_INPUT")')
+            self.input_checks.append(f'{state}<>"INVALID_INPUT"')
+            self.warning("Inputs", state)
+            self.sheets["Inputs"]["validations"].append({"sqref": f'A{rownum}', "formula": f'AND(ISNUMBER(A{rownum}),OR(A{rownum}=0,A{rownum}=1))'})
+            result.append(Row(f'{state}="READY"', args, f'Inputs row {rownum}'))
+            mapped.append({"enabled": enable.replace("'", ""), "args": refs, "status": state.replace("'", "")})
+        self.nr["Inputs"] = n + 4
+        self.mapping["inputs"][pred] = mapped
+        return result
+
+    def normalize(self, pred, args, gate, source):
+        t, s = self.tables[pred], self.settings[pred]
+        if len(args) != t["arity"]:
+            refuse(f"{pred}: арность головы/факта не совпадает")
+        normalized = []
+        for j, (a, kind, scale) in enumerate(zip(args, t["kinds"], s["scales"])):
+            if a.kind != kind:
+                refuse(f"{pred}: вид значения головы/факта не совпадает")
+            if kind in ("dec", "money"):
+                a = self.rescale(a, scale, gate)
+            a = Value(self.helper(a.ref, source + f' / {j + 1}', gate), a.kind, a.scale, a.currency)
+            normalized.append(a)
+        # Head errors must propagate into row presence, not become an absence.
+        active = self.helper(f'IF({conjunction(f"NOT(ISERROR({a.ref}))" for a in normalized)},TRUE(),NA())',
+                             source + " / применимо", gate)
+        return Row(active, normalized, source)
+
+    def rule_rows(self, rule):
+        tables = [self.rows[a["pred"]] for a in rule["atoms"]]
+        count = 1
+        for rows in tables:
+            count *= len(rows)
+        if count + self.slots > MAX_SLOTS:
+            refuse(f"развёртка правил превышает {MAX_SLOTS} строк")
+        for env in itertools.product(*tables):
+            gate = self.helper(conjunction(row.active for row in env), rule["id"] + " / тело")
+            if rule["window"]:
+                for key, op in (("start", ">="), ("end", "<")):
+                    if rule["window"].get(key):
+                        gate = self.helper(f"'Inputs'!B4{op}{date_number(rule['window'][key])}", "Окно правила", gate)
+            for (ai, aj, _), (bi, bj, _) in rule["joins"]:
+                gate = self.helper(self.compare(env[ai].args[aj], env[bi].args[bj], "eq", gate), "Соединение", gate)
+            for f in rule["filters"]:
+                gate = self.helper(self.compare(env[f["row"]].args[f["col"]], self.term(f["term"], env, gate), "eq", gate), "Фильтр", gate)
+            for g in rule["guards"]:
+                gate = self.helper(self.compare(self.term(g["l"], env, gate), self.term(g["r"], env, gate), g["op"], gate), "Условие", gate)
+            args = [self.term(t, env, gate) for t in rule["head"]["args"]]
+            yield self.normalize(rule["head"]["pred"], args, gate, rule["id"])
+
+    def unique(self, row, previous):
+        gate = row.active
+        for prev in previous:
+            same = conjunction(self.compare(a, b, "eq", gate) for a, b in zip(row.args, prev.args))
+            gate = self.helper(f'NOT(AND({prev.active},{same}))', "Устранение дубликата", gate)
+        return Row(gate, row.args, row.source)
+
+    def output(self, pred):
+        rows, t, s = self.rows[pred], self.tables[pred], self.settings[pred]
+        n = self.nr["Results"]
+        self.put("Results", n, 1, s["label"], style="title")
+        for j, v in enumerate(["Состояние"] + s["columns"] + ["Ключ", "Основание"]):
+            self.put("Results", n + 1, j + 1, v, style="header")
+        mapped = []
+        for row in rows:
+            n += 1
+            r = n + 1
+            status = self.put("Results", r, 1, formula=f'IF($B$3<>"READY",$B$3,IF({row.active},"PRESENT","NEITHER"))')
+            refs = []
+            for j, a in enumerate(row.args):
+                expr = f'{a.ref}/{10 ** a.scale}' if a.kind in ("dec", "money") else a.ref
+                refs.append(self.put("Results", r, j + 2, formula=f'IF({status}="PRESENT",{expr},"")',
+                                     style="date" if a.kind == "date" else f"num{a.scale}" if a.kind in ("dec", "money") else "body").replace("'", ""))
+            conflicts = []
+            for key in t["keys"]:
+                for other in rows:
+                    if other is row:
+                        continue
+                    same = conjunction(self.compare(row.args[i], other.args[i], "eq", "TRUE()") for i in key)
+                    conflicts.append(f'AND({other.active},{same})')
+            conflict = "FALSE()" if not conflicts else f'NOT({conjunction("NOT(" + c + ")" for c in conflicts)})'
+            keycell = self.put("Results", r, t["arity"] + 2,
+                               formula=f'IF({status}="PRESENT",IF({conflict},"KEY_CONFLICT",""),"")')
+            self.warning("Results", status)
+            self.warning("Results", keycell)
+            self.put("Results", r, t["arity"] + 3, row.source)
+            mapped.append({"status": status.replace("'", ""), "args": refs, "key": keycell.replace("'", "")})
+        if not rows:
+            self.put("Results", n + 2, 1, formula='IF($B$3="READY","NEITHER",$B$3)')
+        self.nr["Results"] = n + 5
+        self.mapping["tables"][pred] = mapped
+
+    def build(self):
+        self.validate()
+        for name in self.sheets:
+            title = {"Results": "Arxo · Результаты", "Inputs": "Входные данные", "Calculation": "Вычисление правил", "Model": "Паспорт модели"}[name]
+            self.put(name, 2, 1, title, style="title")
+        self.put("Inputs", 4, 1, "Дата расчёта")
+        on = self.config.get("legalTime")
+        self.put("Inputs", 4, 2, date_number(on) if on else None, style="inputdate")
+        self.put("Inputs", 5, 1, "Жёлтые ячейки — ввод. 1 включает строку, 0 исключает. Новые строки требуют новой сборки.")
+        self.sheets["Inputs"]["validations"].append({"sqref": "B4", "formula": 'AND(ISNUMBER(B4),B4=INT(B4),B4>=61,B4<=2958465)'})
+        self.input_checks.append('IFERROR(AND(ISNUMBER(\'Inputs\'!B4),\'Inputs\'!B4=INT(\'Inputs\'!B4),\'Inputs\'!B4>=61,\'Inputs\'!B4<=2958465),FALSE())')
+        for pred in self.order:
+            base = self.input_rows(pred)
+            candidates = []
+            for row in base:
+                gate = self.helper(row.active, row.source, "'Inputs'!B3=\"READY\"")
+                candidates.append(self.normalize(pred, row.args, gate, row.source))
+            for fact in self.plan["facts"]:
+                fields(fact, {"pred", "args"}, "факт")
+                if fact["pred"] not in self.tables:
+                    refuse("факт необъявленного предиката")
+                if fact["pred"] == pred:
+                    args = [self.term(a, [], "'Inputs'!B3=\"READY\"") for a in fact["args"]]
+                    candidates.append(self.normalize(pred, args, "'Inputs'!B3=\"READY\"", "Факт пакета"))
+            for rule in self.plan["rules"]:
+                if rule["head"]["pred"] == pred:
+                    candidates.extend(self.rule_rows(rule))
+            self.slots += len(candidates)
+            if self.slots > MAX_SLOTS:
+                refuse(f"более {MAX_SLOTS} строк")
+            self.rows[pred] = []
+            for row in candidates:
+                self.rows[pred].append(self.unique(row, self.rows[pred]))
+        self.put("Inputs", 3, 1, "Состояние ввода")
+        self.put("Inputs", 3, 2, formula=f'IF({conjunction(self.input_checks)},"READY","INVALID_INPUT")')
+        for pred in reversed(self.order):
+            if pred != P.ALWAYS:
+                self.output(pred)
+        self.put("Results", 3, 1, "Состояние расчёта")
+        self.put("Results", 3, 2,
+                 formula=f'IF(\'Inputs\'!B3<>"READY","INVALID_INPUT",IF(SUM(\'Calculation\'!D7:D{max(7, self.nr["Calculation"] - 1)})>0,"CALCULATION_REFUSED","READY"))')
+        self.warning("Results", "B3")
+        self.warning("Inputs", "B3")
+        self.put("Results", 4, 1, "PRESENT — строка выведена; NEITHER — вывод отсутствует. KEY_CONFLICT — несколько значений одного ключа.")
+        self.put("Results", 5, 1, "CALCULATION_REFUSED — точность/диапазон числа или деление. Ошибка видна на листе Calculation.")
+        for j, v in enumerate(["Шаг / основание", "Вычислено", "После проверки", "Ошибка"]):
+            self.put("Calculation", 6, j + 1, v, style="header")
+        metadata = [("Профиль", PROFILE), ("Версия плана", self.plan["planVersion"]),
+                    ("Пакет", (self.plan.get("package") or {}).get("name", "")),
+                    ("Семантический хэш", self.config.get("semanticHash", "не задан")),
+                    ("Валюта", self.numeric_currency or "не используется"),
+                    ("Точность", f"Целочисленные коэффициенты до ±{LIMIT}; масштаб входа 0..6; промежуточный 0..12"),
+                    ("Деление", "Точное десятичное частное до 6 разрядов (либо больший исходный масштаб); иначе отказ"),
+                    ("Даты", "1900-03-01..9999-12-31; система дат Excel 1900"),
+                    ("Граница", "Строгие положительные правила без рекурсии; без канонического proof-документа"),
+                    ("Пересчёт", "Автоматический; книга работает самостоятельно, без Arxo и макросов"),
+                    ("Пустые значения", "Пустой аргумент включённой строки — INVALID_INPUT; отсутствующий факт — строка выключена"),
+                    ("Сравнение текста", "С учётом регистра; пустой текст вне входного профиля"),
+                    ("Редактирование", "Меняйте только жёлтые ячейки Inputs. Остальные ячейки — программа модели.")]
+        metadata += [("Зависимость", json.dumps(w, ensure_ascii=False)) for w in self.plan.get("world", [])]
+        for q in (self.plan.get("api") or {}).get("questions", []):
+            for source in q.get("sources", []):
+                for anchor in source.get("anchors", []):
+                    metadata.append(("Источник / " + source["rule"], json.dumps(anchor, ensure_ascii=False)))
+        for i, (label, value) in enumerate(metadata, 4):
+            self.put("Model", i, 1, label)
+            self.put("Model", i, 2, value)
+        # Effective configuration is a reproducible input contract.
+        self.mapping["config"] = dict(self.config, profile=PROFILE, tables=self.settings)
+        self.mapping["limits"] = {"integerCoefficient": LIMIT, "candidateRows": MAX_SLOTS, "cells": MAX_CELLS}
+        return {"format": FORMAT, "profile": PROFILE, "sheets": list(self.sheets.values()), "mapping": self.mapping}
+
+
+def build(plan, config=None):
+    return Planner(plan, config).build()