arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/py/emit.py

@@ -0,0 +1,1140 @@
+#!/usr/bin/env python3
+"""Эмиттер Python. Тот же план, другой синтаксис и тот же контракт рантайма."""
+import json
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+# План поражаемого слоя (DECISION-0237) — отдельная версия со своей печатью.
+SUPPORTED_PLAN_L1 = "law-backend-plan/0.8"
+# План с агрегатами §59 в правилах и замыканиями §70 (DECISION-0239).
+SUPPORTED_PLAN_09 = "law-backend-plan/0.9"
+# План с нормативными позициями L2 (DECISION-0242).
+SUPPORTED_PLAN_10 = "law-backend-plan/0.10"
+# План с календарными функциями §84–§86 (DECISION-0245).
+SUPPORTED_PLAN_11 = "law-backend-plan/0.11"
+# План с Rational §35/§58 (DECISION-0252).
+SUPPORTED_PLAN_12 = "law-backend-plan/0.12"
+# План с Quantity §49 v1 и счётчиком-связывателем §86.1 (DECISION-0256).
+SUPPORTED_PLAN_13 = "law-backend-plan/0.13"
+# План с политикой округления §50 (DECISION-0259).
+SUPPORTED_PLAN_14 = "law-backend-plan/0.14"
+# План с Boolean/Natural, границами месяца §84.2 и `_` §98 (DECISION-0266–0268).
+SUPPORTED_PLAN_15 = "law-backend-plan/0.15"
+# План с датированными приоритетами §92.3 (DECISION-0269).
+SUPPORTED_PLAN_16 = "law-backend-plan/0.16"
+# План с вычисляемым аргументом атома тела и условным термом §56 (DECISION-0270).
+SUPPORTED_PLAN_17 = "law-backend-plan/0.17"
+# План 0.18 (DECISION-0273): функции §46, параметры A3, `let`, `match`.
+SUPPORTED_PLAN_18 = "law-backend-plan/0.18"
+# План 0.19 (DECISION-0274): канал суждения §47.3.
+SUPPORTED_PLAN_19 = "law-backend-plan/0.19"
+# Возможности плана, которые цель печатает; поставка сверяет их до эмиссии.
+CAPABILITIES = {"admission:current", "defeasible", "negation", "priority", "status:not_known", "status:unknown",
+                "function", "param:a3", "term:let", "term:match", "judgment",
+                "status:refuted", "status:monotone", "status:supported", "aggregate", "closure",
+                "calendar:days_between", "calendar:period", "calendar:business", "value:rational",
+                "value:quantity", "value:round", "value:div_round",
+                "value:boolean", "value:natural", "calendar:month_bound", "wildcard", "priority:dated", "term:body", "term:if",
+                "value:instant"}
+PHASES = {"strict", "closure", "candidates", "defeat", "surviving", "status", "norms", "effects"}
+# Поля фаз расписания: незнакомое поле печаталось бы молча. `waiting` —
+# правила, ждущие замыкания §70 (errata E-0174).
+PHASE_FIELDS = {"strict": {"phase", "waiting"}, "closure": {"phase", "policies"},
+                "candidates": {"phase", "stratum", "rules"}, "defeat": {"phase", "stratum"},
+                "surviving": {"phase", "stratum"}, "status": {"phase", "stratum"},
+                "norms": {"phase"}, "effects": {"phase"}}
+
+
+def check_plan(plan: dict) -> None:
+    if "norms" in plan or "norm" in (plan.get("capabilities") or []):
+        raise ValueError("NORM_RANKS_UNAVAILABLE: norm runtime requires current ranks (W6)")
+    v = plan.get("basePlanVersion") if plan.get("planVersion") == "law-backend-plan/0.20" else plan.get("planVersion")
+    if v not in (SUPPORTED_PLAN, SUPPORTED_PLAN_L1, SUPPORTED_PLAN_09, SUPPORTED_PLAN_10, SUPPORTED_PLAN_11,
+                 SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19):
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержаны {SUPPORTED_PLAN}, "
+                         f"{SUPPORTED_PLAN_L1}, {SUPPORTED_PLAN_09}, {SUPPORTED_PLAN_10}, {SUPPORTED_PLAN_11}, "
+                         f"{SUPPORTED_PLAN_12}, {SUPPORTED_PLAN_13}, {SUPPORTED_PLAN_14}, {SUPPORTED_PLAN_15}, {SUPPORTED_PLAN_16}, {SUPPORTED_PLAN_17}, {SUPPORTED_PLAN_18}, {SUPPORTED_PLAN_19})")
+    missing = sorted(set(plan.get("capabilities") or ()) - CAPABILITIES)
+    if missing:
+        raise ValueError(f"возможности плана не поддержаны эмиттером: {', '.join(missing)}")
+
+
+def _judgments(L: list, plan: dict) -> None:
+    """Отношения суждения §47.3 (DECISION-0274): орган и форма запроса по
+    отношению — для обхода запроса судье в рантайме и проверки ответа §47.3.1."""
+    L.append("")
+    L.append("# Отношения суждения §47.3 (DECISION-0274): орган и форма запроса.")
+    L.append("JUDGMENTS = " + json.dumps(plan.get("judgments") or {}, ensure_ascii=False))
+
+
+def _functions(L: list, plan: dict) -> None:
+    """Функции §46 и параметры A3 (DECISION-0273). Функции печатаются
+    функциями цели по позиционным параметрам и экспортируются раннеру для
+    вопросов `term`; параметр A3 — значение на legal_time из `prepare`."""
+    L.append("")
+    L.append("# Функции §46 (DECISION-0273): чистые тела по позиционным параметрам.")
+    L.append("def _match_fail():")
+    L.append('    raise RT.TermError("NON_EXHAUSTIVE_MATCH")')
+    L.append("")
+    for f in plan.get("functions") or []:
+        params = ", ".join(f"a{i}" for i in range(len(f["params"])))
+        L.append(f'def f_{f["name"]}({params}):')
+        L.append(f'    return {term(f["body"])}')
+        L.append("")
+    L.append("FUNCTIONS = {")
+    for f in plan.get("functions") or []:
+        L.append(f'    {json.dumps(f["id"])}: (f_{f["name"]}, {json.dumps(f["paramTypes"])}, {json.dumps(f["returnType"])}),')
+    L.append("}")
+    L.append("# Параметры A3 §A3.2: окна [start, end) оси права со значением; активное значение")
+    L.append("# готовит `prepare` по legal_time, разрыв датасета — MISSING_PARAMETER_VALUE правила.")
+    L.append("A3_TYPES = " + json.dumps({p["id"]: p["type"] for p in plan.get("a3Params") or []}, ensure_ascii=False))
+    if plan.get("a3Params"):
+        L.append("A3_WINDOWS = [")
+        for p in plan["a3Params"]:
+            ws = ", ".join(f"({s!r}, {e!r}, {term(v)})" for s, e, v in p["windows"])
+            L.append(f'    ({json.dumps(p["id"])}, [{ws}]),')
+        L.append("]")
+        L.append("A3 = {}")
+        L.append("")
+        L.append("def _a3(id):")
+        L.append("    if id not in A3:")
+        L.append('        raise RT.TermError("MISSING_PARAMETER_VALUE")')
+        L.append("    return A3[id]")
+        L.append("")
+
+
+def _calendar_env(L: list, plan: dict) -> None:
+    """Окружение календаря (DECISION-0245 п. 3–4): раннер выбирает снимок и
+    политику дела до вывода."""
+    if "calendars" in plan:
+        L.append("# §85/§86 (DECISION-0245): версия семантики, политики и снимки программы.")
+        L.append(f'CAL_SEMVER = {json.dumps(plan["semanticVersion"])}')
+        L.append(f'CAL_POLICIES = {plan["deadlinePolicies"]!r}')
+        L.append(f'CAL_SNAPSHOTS = {plan["calendars"]!r}')
+    if "backchain" in plan:
+        L.append("# E-0105: правила для обхода ошибок терма от цели вопроса.")
+        L.append(f'BACKCHAIN = {plan["backchain"]!r}')
+        L.append(f'BACKCHAIN_CONSTS = {plan["backchainConsts"]!r}')
+
+
+def _is_l1(plan: dict) -> bool:
+    """Модель L1: у плана 0.11 — по расписанию фаз (DECISION-0245 п. 1)."""
+    return plan["planVersion"] in (SUPPORTED_PLAN_L1, SUPPORTED_PLAN_09, SUPPORTED_PLAN_10) or \
+        (plan["planVersion"] in (SUPPORTED_PLAN_11, SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19) and "schedule" in plan)
+
+
+def _is_09(plan: dict) -> bool:
+    return plan["planVersion"] in (SUPPORTED_PLAN_09, SUPPORTED_PLAN_10) or \
+        (plan["planVersion"] in (SUPPORTED_PLAN_11, SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19) and "aggregates" in plan)
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "qty":
+        # Счётчик календарной функции (DECISION-0245 п. 2): число и единица.
+        return f'{t["v"]}, {json.dumps(t["unit"])}'
+    if k == "qtyvar":
+        # Счётчик-связыватель §86.1 (DECISION-0256 п. 6): число и единица проверяются на деле.
+        return f'*RT.counter({term(t["term"])}, {json.dumps(t["fn"])})'
+
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money("{t["v"]}", "{t["cur"]}")'
+        if t["t"] == "dec":
+            return f'RT.dec("{t["v"]}")'
+        if t["t"] == "date":
+            return f'RT.date("{t["v"]}")'
+        if t["t"] == "inst":
+            return f'RT.instant("{t["v"]}")'
+        if t["t"] == "enum":
+            return f'RT.sym("{t["v"]}")'
+        if t["t"] == "rat":
+            return f'RT.rat("{t["v"]}")'
+        if t["t"] == "qty":
+            return f'RT.qty("{t["v"]}", {json.dumps(t["unit"], ensure_ascii=False)})'
+        if t["t"] == "bool":
+            # DECISION-0266: булево — литерал языка, не JSON.
+            return "True" if t["v"] else "False"
+        return json.dumps(t["v"], ensure_ascii=False)
+    if k == "bin":
+        if "lk" in t:
+            # DECISION-0252 п. 3: пара §58 решается статическими видами операндов.
+            return f'RT.arith("{t["op"]}", {term(t["l"])}, {term(t["r"])}, "{t["lk"]}", "{t["rk"]}")'
+        return f'RT.{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        if "ak" in t:
+            # DECISION-0259 п. 2: политика §50 проверяется рантаймом; виды
+            # значения и точности — из плана (последний вид — Text режима).
+            name = "round_mode" if t["fn"] == "round" else t["fn"]
+            return (f'RT.{name}(' + ", ".join(term(a) for a in t["args"]) + ", "
+                    + ", ".join(json.dumps(c) for c in t["ak"][:-1]) + ')')
+        return f'RT.{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ')'
+    if k == "param":
+        return f'p{t["i"]}'
+    if k == "fvar":
+        # DECISION-0273: параметр функции §46 — позиционный аргумент.
+        return f'a{t["i"]}'
+    if k == "lvar":
+        return f'l{t["i"]}'
+    if k == "fcall":
+        return f'f_{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ')'
+    if k == "a3":
+        # Параметр A3: значение на legal_time готовит `prepare`; разрыв — TermError.
+        return f'_a3({json.dumps(t["id"])})'
+    if k == "let":
+        # §55: значение считается один раз, тело — с локальным связыванием.
+        return f'(lambda l{t["i"]}: {term(t["b"])})({term(t["v"])})'
+    if k == "match":
+        # §55.1: первая совпавшая ветвь; ни одна — NON_EXHAUSTIVE_MATCH.
+        out = "_match_fail()"
+        for arm in reversed(t["arms"]):
+            if arm["m"] is None:
+                out = term(arm["v"])
+            else:
+                out = f'({term(arm["v"])} if RT.eq(s, RT.sym({json.dumps(arm["m"])})) else {out})'
+        return f'(lambda s: {out})({term(t["s"])})'
+    if k == "agg":
+        return f'{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ')'
+    if k == "if":
+        # §56 (DECISION-0270): ленивая ветвь — условное выражение.
+        return f'({term(t["t"])} if {cond(t["c"])} else {term(t["e"])})'
+    raise AssertionError(k)
+
+
+def cond(c: dict) -> str:
+    """Data-условие §56: boolean, сравнение, and, or."""
+    k = c["k"]
+    if k == "bool":
+        return "True" if c["v"] else "False"
+    if k == "cmp":
+        return f'RT.cmp({term(c["l"])}, "{c["op"]}", {term(c["r"])})'
+    if k in ("and", "or"):
+        return "(" + f" {k} ".join(cond(x) for x in c["items"]) + ")"
+    raise AssertionError(k)
+
+
+# Виды ячеек, на которых `eq` рантайма не отказывает: проверку соединения
+# можно поставить на уровень атома, который её связывает, — ответ и отказы
+# прежние, а декартово произведение не строится (у `algo.*` шесть атомов
+# тела давали минуты на пустом деле). Соединение над деньгами отказывает на
+# разных валютах, поэтому при нём правило печатается прежним порядком.
+_EARLY_KINDS = {"text", "enum", "date", "dec"}
+
+
+def _py_wild_open(L: list, ind: str, i: int, a: dict) -> None:
+    """§98 (DECISION-0268): множество проекций строк атома с `_` — на уровне
+    цикла, то есть заново на каждой подстановке внешних атомов."""
+    if a.get("wild"):
+        L.append(f'{ind}w{i} = set()')
+
+
+def _py_wild(L: list, ind: str, i: int, a: dict) -> None:
+    """Строки, различающиеся только в столбцах `_`, дают одну подстановку."""
+    if a.get("wild"):
+        cells = ", ".join(f"r{i}[{c}]" for c in a["keep"])
+        L.append(f'{ind}wk{i} = RT.key([{cells}])')
+        L.append(f'{ind}if wk{i} in w{i}: continue')
+        L.append(f'{ind}w{i}.add(wk{i})')
+
+
+def _py_checks(L: list, ind: str, checks: list) -> None:
+    for kind, c in checks:
+        if kind == "join":
+            (ai, aj, _at), (bi, bj, _bt) = c
+            L.append(f'{ind}if not RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]): continue')
+        else:
+            L.append(f'{ind}if not RT.eq(r{c["row"]}[{c["col"]}], {term(c["term"])}): continue')
+
+
+def _early(r: dict) -> tuple[dict, list, list]:
+    """Проверки по уровням атомов `{i: [строки-проверки]}` и оставшиеся во
+    внутреннем цикле соединения и фильтры (порядок печати прежний)."""
+    joins, filters = r["joins"], r["filters"]
+    if any(at not in _EARLY_KINDS or bt not in _EARLY_KINDS for (_ai, _aj, at), (_bi, _bj, bt) in joins):
+        return {}, joins, filters
+    levels: dict = {}
+    for j in joins:
+        levels.setdefault(j[1][0], []).append(("join", j))
+    for f in filters:
+        levels.setdefault(f["row"], []).append(("filter", f))
+    return levels, [], []
+
+
+def _key_scope(L: list, plan: dict) -> None:
+    """Emit the §181.2 forward predicate graph for KEY_CONFLICT locality."""
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        head = rule["head"]["pred"]
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(head)
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(head)
+    L.append("# E-0210/E-0242: конфликт ключа блокирует только читающий его запрос.")
+    L.append("KEY_READERS = " + repr({key: sorted(value) for key, value in sorted(readers.items())}))
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    if plan.get("planVersion") == "law-backend-plan/0.20":
+        plan = dict(plan, planVersion=plan["basePlanVersion"],
+                    capabilities=[c for c in plan["capabilities"] if c != "admission:current"])
+    if _is_l1(plan):
+        return emit_l1(plan)
+    L = ["import runtime as RT", "", "TABLES = {"]
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])}: [],')
+    L.append("}")
+    _key_scope(L, plan)
+    L.append("")
+    L.append("# Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("PARAMS = {")
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])}: {json.dumps(t["params"], ensure_ascii=False)},')
+    L.append("}")
+    L.append("")
+    L.append("# Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("CONSTS = {")
+    for cid, c in plan["consts"].items():
+        L.append(f'    {json.dumps(cid)}: ({json.dumps(c["type"])}, {term(c["term"])}),')
+    L.append("}")
+    L.append("")
+    L.append("# Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append(f'BASES = {json.dumps(plan["bases"], ensure_ascii=False)}')
+    _functions(L, plan)
+    _judgments(L, plan)
+    _calendar_env(L, plan)
+    L.append("")
+    L.append("# Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("KEYS = {")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'    {json.dumps(t["pred"])}: {json.dumps(t["keys"])},')
+    L.append("}")
+    L.append("")
+    L.append("# E-0243 §181.2: forward predicate dependencies for carrier issues.")
+    L.append("CARRIER_EDGES = {")
+    edges = {}
+    for r in plan["rules"]:
+        edges.setdefault(r["head"]["pred"], []).extend(atom["pred"] for atom in r.get("atoms", []))
+    for head, deps in sorted(edges.items()):
+        L.append(f'    {json.dumps(head)}: {json.dumps(list(dict.fromkeys(deps)))},')
+    L.append("}")
+    L.append("")
+    L.append("_seen = set()")
+    L.append("")
+    L.append("def add(urn, row):")
+    L.append('    k = (urn, RT.key(row))')
+    L.append("    if k in _seen: return False")
+    L.append("    _seen.add(k); TABLES[urn].append(row); return True")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'# {r["id"]}')
+        L.append(f'def rule_{r["name"]}():')
+        L.append("    grew = False")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'    if RT.legal_time() < "{r["window"]["start"]}": return False')
+            if r["window"].get("end"):
+                L.append(f'    if RT.legal_time() >= "{r["window"]["end"]}": return False')
+        ind = "    "
+        levels, late_joins, late_filters = _early(r)
+        for i, a in enumerate(r["atoms"]):
+            _py_wild_open(L, ind, i, a)
+            L.append(f'{ind}for r{i} in TABLES[{json.dumps(a["pred"])}]:')
+            ind += "    "
+            _py_checks(L, ind, levels.get(i, []))
+            _py_wild(L, ind, i, a)
+        for (ai, aj, _at), (bi, bj, _bt) in late_joins:
+            L.append(f'{ind}if not RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]): continue')
+        for f in late_filters:
+            L.append(f'{ind}if not RT.eq(r{f["row"]}[{f["col"]}], {term(f["term"])}): continue')
+        for g in r["guards"]:
+            L.append(f'{ind}if not RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}): continue')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if add({json.dumps(r["head"]["pred"])}, [{args}]): grew = True')
+        L.append("    return grew")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("def saturate():")
+    L.append("    grew = True")
+    L.append("    while grew:")
+    if names:
+        L.append("        grew = any([" + ", ".join(f"rule_{n}()" for n in names) + "])")
+    else:
+        L.append("        grew = False")
+    L.append("")
+    L.append("def register(urn, row):")
+    L.append("    add(urn, row)")
+    L.append("")
+    L.append("# Статус строки §62 у модели L0 — для обхода запроса судье §47.3 (DECISION-0274).")
+    L.append("def status(urn, row):")
+    L.append('    return "TRUE_ONLY" if any(len(r) == len(row) and all(RT.eq(v, row[i]) for i, v in enumerate(r)) for r in TABLES.get(urn, [])) else "NEITHER"')
+    L.append("")
+    L.append("# KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией")
+    L.append("# на ключ; строки уникальны по ключу строки, поэтому группа из двух и более")
+    L.append("# строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("def key_conflicts():")
+    L.append("    n = 0")
+    L.append("    for urn, keys in KEYS.items():")
+    L.append("        for key in keys:")
+    L.append("            groups = {}")
+    L.append("            for row in TABLES[urn]:")
+    L.append("                p = RT.key([row[i] for i in key])")
+    L.append("                groups[p] = groups.get(p, 0) + 1")
+    L.append("            n += sum(1 for c in groups.values() if c > 1)")
+    L.append("    return n")
+    L.append("def key_conflict_predicates():")
+    L.append("    out = set()")
+    L.append("    for urn, keys in KEYS.items():")
+    L.append("        for key in keys:")
+    L.append("            groups = {}")
+    L.append("            for row in TABLES[urn]:")
+    L.append("                p = RT.key([row[i] for i in key]); groups[p] = groups.get(p, 0) + 1")
+    L.append("            if any(c > 1 for c in groups.values()): out.add(urn)")
+    L.append("    return out")
+    L.append("")
+    L.append("# Собственные факты пакета; `reset` возвращает модель к ним (чистое `evaluate` API).")
+    L.append("def package_facts():")
+    for f in plan["facts"]:
+        L.append(f'    add({json.dumps(f["pred"])}, [' + ", ".join(term(a) for a in f["args"]) + '])')
+    L.append("    pass")
+    L.append("")
+    L.append("def reset():")
+    L.append("    for rows in TABLES.values(): rows.clear()")
+    L.append("    _seen.clear()")
+    L.append("    package_facts()")
+    L.append("")
+    L.append("package_facts()")
+    return _factory("\n".join(L) + "\n", plan)
+
+
+def _factory(src: str, plan: dict) -> str:
+    """Модель — фабрика состояния на вызов (DECISION-0423 §2.3). Тело модуля
+    модели целиком становится телом `new_model()`: таблицы, опоры, кандидаты
+    и issues — локальные переменные вызова, правила — замыкания над ними;
+    `global` модуля становится `nonlocal`. Возвращается пространство имён тех
+    же имён, что раньше были атрибутами модуля, поэтому вход `evaluate` читает
+    модель как прежде, но каждый вызов получает своё состояние."""
+    src += "NODE_IDS = " + repr((plan.get("admission") or {}).get("reservedAssertionIds", [])) + "\n"
+    lines = src.rstrip("\n").split("\n")
+    if lines[0] != "import runtime as RT":
+        raise ValueError("модель без заголовка импорта рантайма")
+    out = ["import types as _types", "import runtime as RT", "", "",
+           "def new_model():",
+           '    """Новое состояние модели на одно вычисление (DECISION-0423 §2.3)."""']
+    for ln in lines[1:]:
+        if not ln.strip():
+            out.append("")
+            continue
+        if ln.lstrip().startswith("global "):
+            ln = ln.replace("global ", "nonlocal ", 1)
+        out.append("    " + ln)
+    out.append("    return _types.SimpleNamespace(**{k: v for k, v in locals().items() if not k.startswith('__')})")
+    return "\n".join(out) + "\n"
+
+
+# --- поражаемый слой L1 (DECISION-0237) ---------------------------------------
+# Опоры хранятся битами происхождения на ключ строки: strict/asserted и
+# surviving-defeasible по обеим полярностям (F3); TruthStatus §62 выводится
+# при чтении. Кандидаты — отдельная таблица с идентичностью «правило +
+# подстановка», defeat — локальный helper над полным снимком кандидатов.
+# Страты и порядок фаз §111 решил план; эмиттер печатает их циклами.
+
+def _steps(L: list, body: dict, ind: str) -> str:
+    """Шаги тела плана 0.9 в порядке `solve`: генератор открывает цикл, его
+    соединения и фильтры стоят сразу за ним; проверка и гард — там, где их
+    переменные связаны. Возвращает отступ самого внутреннего уровня."""
+    L.append(f"{ind}for _once in (0,):")
+    ind += "    "
+    for step in body["steps"]:
+        if "gen" in step:
+            i = step["gen"]
+            a = body["atoms"][i]
+            p = json.dumps(a["pred"])
+            for f in body["filters"]:
+                if f["row"] == i and f.get("pre"):
+                    # DECISION-0270: вычисляемый аргумент считается ДО перебора
+                    # таблицы (`solver.solve`); ошибка значения — код по подстановке.
+                    name = f'pre{i}_{f["col"]}'
+                    if f.get("err"):
+                        L.append(f'{ind}try:')
+                        L.append(f'{ind}    {name} = {term(f["term"])}')
+                        L.append(f'{ind}except RT.TermError as _e:')
+                        L.append(f'{ind}    _codes.add(_e.code); continue')
+                    else:
+                        L.append(f'{ind}{name} = {term(f["term"])}')
+            _py_wild_open(L, ind, i, a)
+            L.append(f'{ind}for i{i}, r{i} in enumerate(TABLES[{p}]):')
+            ind += "    "
+            L.append(f'{ind}if mask_status(SUP[{p}][RK[{p}][i{i}]]) not in {tuple(a["accept"])!r}: continue')
+            for (ai, aj, _at), (bi, bj, _bt) in body["joins"]:
+                if bi == i:
+                    L.append(f'{ind}if not RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]): continue')
+            for f in body["filters"]:
+                if f["row"] == i:
+                    value = f'pre{i}_{f["col"]}' if f.get("pre") else term(f["term"])
+                    L.append(f'{ind}if not RT.eq(r{f["row"]}[{f["col"]}], {value}): continue')
+            _py_wild(L, ind, i, a)
+        elif "check" in step:
+            c = body["checks"][step["check"]]
+            args = ", ".join(term(a) for a in c["args"])
+            if c.get("err"):
+                # DECISION-0270: ошибка значения аргумента проверки — код по подстановке.
+                L.append(f'{ind}try:')
+                L.append(f'{ind}    _a = [{args}]')
+                L.append(f'{ind}except RT.TermError as _e:')
+                L.append(f'{ind}    _codes.add(_e.code); continue')
+                L.append(f'{ind}if status({json.dumps(c["pred"])}, _a) not in {tuple(c["accept"])!r}: continue')
+            else:
+                L.append(f'{ind}if status({json.dumps(c["pred"])}, [{args}]) not in {tuple(c["accept"])!r}: continue')
+        else:
+            g = body["guards"][step["guard"]]
+            if g.get("cal") or g.get("err"):
+                # DECISION-0245 п. 6, DECISION-0252 п. 4: код ошибки значения — по подстановкам.
+                L.append(f'{ind}try:')
+                L.append(f'{ind}    _ok = RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})')
+                L.append(f'{ind}except RT.TermError as _e:')
+                L.append(f'{ind}    _codes.add(_e.code); continue')
+                L.append(f'{ind}if not _ok: continue')
+            else:
+                L.append(f'{ind}if not RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}): continue')
+    return ind
+
+
+def _aggregates(L: list, plan: dict) -> None:
+    """Подпланы агрегатов §59: материализация comprehension §52.1 по
+    установленным строкам и свёртка; ошибка значения — `AggError` с кодом."""
+    for a in plan.get("aggregates") or []:
+        params = ", ".join(f"p{i}" for i in range(len(a["params"])))
+        L.append(f'def items_{a["name"]}({params}):')
+        L.append("    items, seen = [], set()")
+        ind = _steps(L, a, "    ")
+        L.append(f'{ind}v = {term(a["element"])}')
+        if a["distinct"]:
+            L.append(f"{ind}k = RT.key([v])")
+            L.append(f"{ind}if k in seen: continue")
+            L.append(f"{ind}seen.add(k)")
+        L.append(f"{ind}items.append(v)")
+        L.append("    return items")
+        L.append("")
+        L.append(f'def {a["name"]}({params}):')
+        L.append(f'    items = items_{a["name"]}({params})')
+        if a["op"] == "count":
+            L.append("    return RT.dec(str(len(items)))")
+        else:
+            L.append("    if not items:")
+            if a["empty"] is not None:
+                L.append(f'        return {term(a["empty"])}')
+            else:
+                L.append('        raise AggError("EMPTY_AGGREGATE")')
+            if a["op"] == "only":
+                # §51 (errata E-0256): единственное РАЗЛИЧНОЕ значение — по
+                # каноническому ключу, тем же, что у distinct; кратность безразлична.
+                L.append("    if len({RT.key([x]) for x in items}) > 1:")
+                L.append('        raise AggError("CARDINALITY_CONFLICT")')
+                L.append("    return items[0]")
+            else:
+                L.append("    acc = items[0]")
+                fn = {"sum": "add", "min": "min", "max": "max"}[a["op"]]
+                L.append(f"    for x in items[1:]: acc = RT.{fn}(acc, x)")
+                L.append("    return acc")
+        L.append("")
+        L.append(f'def neg_{a["name"]}({params}):')
+        L.append("    # E-0116: отрицательное слагаемое под монотонным гардом sum")
+        L.append(f'    return any(RT.cmp(x, "lt", RT.sub(x, x)) for x in items_{a["name"]}({params}))')
+        L.append("")
+
+
+def _rule09(L: list, r: dict, value: bool = False) -> None:
+    """Правило плана 0.9. Фоллибельное (агрегат с ошибкой значения) копит
+    выводы и применяет их только без ошибки — как `list(solve(...))` оракула.
+    `value` — план 0.12 (DECISION-0252): ошибки значения §58 и сверка вида."""
+    L.append(f'# {r["id"]} ({r["strength"]})')
+    L.append(f'def rule_{r["name"]}():')
+    L.append("    grew = False")
+    if r["window"]:
+        if r["window"].get("start"):
+            L.append(f'    if RT.legal_time() < "{r["window"]["start"]}": return False')
+        if r["window"].get("end"):
+            L.append(f'    if RT.legal_time() >= "{r["window"]["end"]}": return False')
+    L.append("    out = []")
+    cal = r.get("headFallible") or any(g.get("cal") or g.get("err") for g in r["guards"]) \
+        or any(f.get("err") for f in r["filters"]) or any(c.get("err") for c in r["checks"])
+    if cal:
+        L.append("    _codes, _hcodes = set(), set()")
+    L.append("    try:")
+    ind = _steps(L, r, "        ")
+    for a in r.get("addends") or []:
+        args = ", ".join(term(x) for x in a["args"])
+        L.append(f'{ind}if neg_{a["fn"]}({args}):')
+        L.append(f'{ind}    issue({json.dumps(r["name"])}, "MONOTONE_GUARD_NEGATIVE_ADDEND"); continue')
+    args = ", ".join(term(a) for a in r["head"]["args"])
+    pos = r["head"]["polarity"] == "positive"
+    if r.get("headFallible"):
+        L.append(f"{ind}try:")
+        L.append(f"{ind}    _row = [{args}]")
+        L.append(f"{ind}except (RT.TermError, AggError) as _e:" if r.get("headAgg") else f"{ind}except RT.TermError as _e:")
+        L.append(f"{ind}    _hcodes.add(_e.code); continue")
+        args = "*_row"
+    elif r.get("kindChecks"):
+        L.append(f"{ind}_row = [{args}]")
+        args = "*_row"
+    for pos, want in r.get("kindChecks") or []:
+        # E-0077 (DECISION-0252 п. 5): вид значения против слота — вывод не принят.
+        L.append(f'{ind}if RT.kind_of(_row[{pos}]) != "{want}":')
+        L.append(f'{ind}    kind_issue({json.dumps(r["name"])}, {json.dumps(r["head"]["pred"])}, {pos}, _row[{pos}]); continue')
+    L.append(f"{ind}out.append([{args}])")
+    if r["strength"] == "strict":
+        pass
+    else:
+        subst = ", ".join(term(a) for a in r["subst"])
+        L[-1] = f"{ind}out.append(([{args}], [{subst}]))"
+    L.append("    except AggError as exc:")
+    L.append(f'        issue({json.dumps(r["name"])}, exc.code)')
+    L.append("        return False")
+    if cal:
+        name = json.dumps(r["name"])
+        L.append("    # §58: ошибка гарда снимает правило на проход; ошибка головы снимает только")
+        L.append("    # свою подстановку, issue — по каждому коду однажды (errata E-0265).")
+        what, why = ("значения", "DECISION-0252 п. 4") if value else ("календаря", "DECISION-0245 п. 6")
+        L.append("    if _codes:")
+        L.append("        if len(_codes) > 1:")
+        L.append(f'            raise RT.Refused("коды ошибок {what} в гарде зависят от порядка подстановок ({why}): " + {name})')
+        L.append(f"        issue({name}, next(iter(_codes))); return False")
+        L.append("    for _c in sorted(_hcodes):")
+        L.append(f"        issue({name}, _c)")
+    if r["strength"] == "strict":
+        L.append(f'    for row in out:')
+        L.append(f'        if add({json.dumps(r["head"]["pred"])}, row, {"SP" if pos else "SN"}): grew = True')
+    else:
+        L.append(f'    for row, subst in out:')
+        L.append(f'        cand({json.dumps(r["name"])}, {r["strength"] == "defeater"}, '
+                 f'{json.dumps(r["head"]["pred"])}, {pos}, row, subst)')
+    L.append("    return grew")
+    L.append("")
+
+
+def _waiting_strata(L: list, plan: dict, line, comment: str) -> dict:
+    """Страты strict-прохода без ждущих правил (errata E-0174): у каждого
+    набора `waiting` расписания — своя константа. Кто ждёт, решил план;
+    эмиттер лишь вычёркивает имена. Возвращает набор → имя константы."""
+    out: dict = {}
+    for ph in plan["schedule"]:
+        if ph["phase"] in PHASE_FIELDS and set(ph) - PHASE_FIELDS[ph["phase"]]:
+            raise ValueError(f"поле фазы расписания не поддержано эмиттером: "
+                             f"{sorted(set(ph) - PHASE_FIELDS[ph['phase']])}")
+        key = tuple(ph.get("waiting") or ())
+        if not key or key in out:
+            continue
+        if not set(key) <= {n for s in plan["strata"]["strict"] for n in s}:
+            raise ValueError(f"ждущее правило вне strict-страт плана: {', '.join(key)}")
+        out[key] = f"STRICT_WAIT_{len(out)}"
+        L.append(f"{comment} §70/§231.1 (E-0174): проход до замыкания — без {', '.join(key)}")
+        L.append(line(out[key], [[n for n in s if n not in key] for s in plan["strata"]["strict"]]))
+    return out
+
+
+def emit_l1(plan: dict) -> str:
+    L = ["import runtime as RT", "",
+         "# Модель поражаемого слоя L1 (DECISION-0237): опоры с происхождением,",
+         "# кандидаты и defeat по стратам §111; статус §62 выводится при чтении.",
+         'LAYER = "L1"', "", "TABLES = {"]
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])}: [],')
+    L.append("}")
+    _key_scope(L, plan)
+    L.append("# Ключи строк таблиц — параллельно строкам; опоры — биты на ключ строки.")
+    L.append("RK = {urn: [] for urn in TABLES}")
+    L.append("SUP = {urn: {} for urn in TABLES}")
+    L.append("SP, SN, DP, DN = 1, 2, 4, 8   # strict/asserted +/−, surviving defeasible +/−")
+    L.append("")
+    L.append("# Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("PARAMS = {")
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])}: {json.dumps(t["params"], ensure_ascii=False)},')
+    L.append("}")
+    L.append("")
+    L.append("# Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("CONSTS = {")
+    for cid, c in plan["consts"].items():
+        L.append(f'    {json.dumps(cid)}: ({json.dumps(c["type"])}, {term(c["term"])}),')
+    L.append("}")
+    L.append("")
+    L.append("# Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append(f'BASES = {json.dumps(plan["bases"], ensure_ascii=False)}')
+    _functions(L, plan)
+    _judgments(L, plan)
+    _calendar_env(L, plan)
+    L.append("")
+    L.append("# Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("KEYS = {")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'    {json.dumps(t["pred"])}: {json.dumps(t["keys"])},')
+    L.append("}")
+    L.append("")
+    L.append("# E-0243 §181.2: forward predicate dependencies for carrier issues.")
+    L.append("CARRIER_EDGES = {")
+    edges = {}
+    for r in plan["rules"]:
+        edges.setdefault(r["head"]["pred"], []).extend(atom["pred"] for atom in r.get("atoms", []))
+    for head, deps in sorted(edges.items()):
+        L.append(f'    {json.dumps(head)}: {json.dumps(list(dict.fromkeys(deps)))},')
+    L.append("}")
+    L.append("")
+    L.append("def add(urn, row, bit):")
+    L.append("    k = RT.key(row)")
+    L.append("    sup = SUP[urn]")
+    L.append("    m = sup.get(k)")
+    L.append("    if m is None:")
+    L.append("        sup[k] = bit; TABLES[urn].append(row); RK[urn].append(k); return True")
+    L.append("    if m & bit: return False")
+    L.append("    sup[k] = m | bit; return True")
+    L.append("")
+    L.append("# §62: пара опор (t, f) → статус; опоры — объединение strict и surviving.")
+    L.append("def mask_status(m):")
+    L.append("    pos, neg = m & (SP | DP), m & (SN | DN)")
+    L.append('    return "BOTH" if pos and neg else "TRUE_ONLY" if pos else "FALSE_ONLY" if neg else "NEITHER"')
+    L.append("")
+    L.append("def status(urn, row):")
+    L.append("    sup = SUP.get(urn)")
+    L.append('    return "NEITHER" if sup is None else mask_status(sup.get(RT.key(row), 0))')
+    L.append("")
+    L.append("# Установленные строки (TRUE_ONLY) — перечисление collect и API, без BOTH.")
+    L.append("def established_rows(urn):")
+    L.append("    sup, keys = SUP.get(urn, {}), RK.get(urn, [])")
+    L.append('    return [r for i, r in enumerate(TABLES.get(urn, [])) if mask_status(sup[keys[i]]) == "TRUE_ONLY"]')
+    L.append("")
+    if _is_09(plan):
+        L.append("# Ошибка значения агрегата в правиле (DECISION-0239 G3): issue по правилу")
+        L.append("# и коду однажды, правило на проходе не срабатывает.")
+        L.append("class AggError(Exception):")
+        L.append("    def __init__(self, code):")
+        L.append("        super().__init__(code); self.code = code")
+        L.append("")
+        L.append("RULE_ISSUES, _ISSUE_SEEN = [], set()")
+        L.append("")
+        L.append("def issue(rule, code):")
+        L.append("    if (rule, code) not in _ISSUE_SEEN:")
+        L.append("        _ISSUE_SEEN.add((rule, code)); RULE_ISSUES.append(code)")
+        L.append("")
+        if plan["planVersion"] in (SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19):
+            L.append("# E-0077 (DECISION-0252 п. 5): TYPE_ERROR по правилу, предикату, позиции и")
+            L.append("# фактическому виду однажды; связывается с правилом для статуса вопроса §175.")
+            L.append("_KIND_SEEN = set()")
+            L.append("")
+            L.append("def kind_issue(rule, pred, pos, value):")
+            L.append("    k = (rule, pred, pos, RT.kind_of(value))")
+            L.append("    if k not in _KIND_SEEN:")
+            L.append('        _KIND_SEEN.add(k); issue(rule, "TYPE_ERROR")')
+            L.append("")
+        _aggregates(L, plan)
+    L.append("# Кандидаты §104 страты: идентичность — правило и типизированная подстановка.")
+    L.append("CANDS = {}")
+    L.append('STATS = {"candidates": 0, "groups": 0, "maxGroup": 0}')
+    L.append("")
+    L.append("def cand(rule, defeater, urn, positive, row, subst):")
+    L.append("    k = (rule, RT.key(subst))")
+    L.append("    if k not in CANDS: CANDS[k] = (rule, defeater, urn, positive, row, RT.key(row))")
+    L.append("")
+    L.append("# Приоритет §106: транзитивное замыкание безусловных рёбер (выше, ниже).")
+    L.append("PRIO = {" + ", ".join(f"({json.dumps(a)}, {json.dumps(b)})" for a, b in plan["priorities"]) + "}")
+    dated = "datedPriorities" in plan
+    prep = dated or bool(plan.get("a3Params"))
+    if dated:
+        L.append("# DECISION-0269: датированные рёбра §92.3 — окна [start, end) оси права; активное")
+        L.append("# множество готовится один раз на дело по legal_time (`prepare`, подготовленный контекст).")
+        L.append("DATED_PRIO = " + repr([((a, b), [tuple(w) for w in ws]) for a, b, ws in plan["datedPriorities"]]))
+        L.append("PRIO_ACTIVE = set()")
+    if prep:
+        L.append("")
+        L.append("def _in_window(w, t):")
+        L.append("    return (w[0] is None or t >= w[0]) and (w[1] is None or t < w[1])")
+        L.append("")
+        L.append("def prepare():")
+        L.append("    t = RT.legal_time()")
+    if dated:
+        L.append("    PRIO_ACTIVE.clear(); PRIO_ACTIVE.update(PRIO)")
+        L.append("    for pair, ws in DATED_PRIO:")
+        L.append("        if any(_in_window(w, t) for w in ws): PRIO_ACTIVE.add(pair)")
+        if "datedNormPriorities" in plan:
+            L.append("    NORM_PRIO_ACTIVE.clear(); NORM_PRIO_ACTIVE.update(NORM_PRIO)")
+            L.append("    for pair, ws in DATED_NORM_PRIO:")
+            L.append("        if any(_in_window(w, t) for w in ws): NORM_PRIO_ACTIVE.add(pair)")
+    if plan.get("a3Params"):
+        L.append("    # DECISION-0273: значение параметра A3 на legal_time (подготовленный контекст).")
+        L.append("    A3.clear()")
+        L.append("    for id, ws in A3_WINDOWS:")
+        L.append("        for s, e, v in ws:")
+        L.append("            if _in_window((s, e), t): A3[id] = v")
+    prio = "PRIO_ACTIVE" if dated else "PRIO"
+    L.append("")
+    L.append("# DECISION-0274: применения страт для пути запроса судье — дефитеры, давшие")
+    L.append("# применение (E-0103), и поражённые/уцелевшие поражаемые кандидаты (E-0100).")
+    L.append("APPLIED = []")
+    L.append("")
+    L.append("def support_bits(urn, row):")
+    L.append("    sup = SUP.get(urn)")
+    L.append("    return 0 if sup is None else sup.get(RT.key(row), 0)")
+    L.append("")
+    L.append("# Defeat §107 по ПОЛНОМУ снимку кандидатов страты; группа — ground-кортеж,")
+    L.append("# побеждённые не удаляются по ходу обхода. Возвращает выживших §108.")
+    L.append("def defeat():")
+    L.append("    groups, survived = {}, set()")
+    L.append("    for c in CANDS.values():")
+    L.append("        groups.setdefault((c[2], c[5]), []).append(c)")
+    L.append('    STATS["candidates"] += len(CANDS); STATS["groups"] += len(groups)')
+    L.append("    out = []")
+    L.append("    for g in groups.values():")
+    L.append('        STATS["maxGroup"] = max(STATS["maxGroup"], len(g))')
+    L.append("        for rule, defeater, urn, positive, row, k in g:")
+    L.append("            if defeater: continue")
+    L.append("            # §107.1: strict/asserted опора комплемента побеждает безусловно")
+    L.append("            if SUP[urn].get(k, 0) & (SN if positive else SP): continue")
+    L.append("            # §107.2: противоположный обычный кандидат сильнее")
+    L.append(f"            if any(not o[1] and o[3] != positive and (o[0], rule) in {prio} for o in g): continue")
+    L.append("            # §107.3: дефитер на ту же полярность, не преодолённый приоритетом")
+    L.append(f"            if any(d[1] and d[3] == positive and (rule, d[0]) not in {prio} for d in g): continue")
+    L.append("            out.append((urn, row, positive)); survived.add((rule, urn, positive, k))")
+    L.append("    for rule, defeater, urn, positive, row, k in CANDS.values():")
+    L.append('        APPLIED.append({"rule": rule, "defeater": defeater, "urn": urn, "positive": positive, "key": k,')
+    L.append('                        "defeated": not defeater and (rule, urn, positive, k) not in survived})')
+    L.append("    return out")
+    L.append("")
+    for r in plan["rules"]:
+        if "steps" in r:
+            _rule09(L, r, plan["planVersion"] in (SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19))
+            continue
+        L.append(f'# {r["id"]} ({r["strength"]})')
+        L.append(f'def rule_{r["name"]}():')
+        L.append("    grew = False")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'    if RT.legal_time() < "{r["window"]["start"]}": return False')
+            if r["window"].get("end"):
+                L.append(f'    if RT.legal_time() >= "{r["window"]["end"]}": return False')
+        ind = "    "
+        levels, late_joins, late_filters = _early(r)
+        if not r["atoms"]:
+            L.append(f"{ind}for _once in (0,):")
+            ind += "    "
+        for i, a in enumerate(r["atoms"]):
+            p = json.dumps(a["pred"])
+            _py_wild_open(L, ind, i, a)
+            L.append(f'{ind}for i{i}, r{i} in enumerate(TABLES[{p}]):')
+            ind += "    "
+            L.append(f'{ind}if mask_status(SUP[{p}][RK[{p}][i{i}]]) not in {tuple(a["accept"])!r}: continue')
+            _py_checks(L, ind, levels.get(i, []))
+            _py_wild(L, ind, i, a)
+        for (ai, aj, _at), (bi, bj, _bt) in late_joins:
+            L.append(f'{ind}if not RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]): continue')
+        for f in late_filters:
+            L.append(f'{ind}if not RT.eq(r{f["row"]}[{f["col"]}], {term(f["term"])}): continue')
+        for c in r["checks"]:
+            args = ", ".join(term(a) for a in c["args"])
+            L.append(f'{ind}if status({json.dumps(c["pred"])}, [{args}]) not in {tuple(c["accept"])!r}: continue')
+        for g in r["guards"]:
+            L.append(f'{ind}if not RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}): continue')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        pos = r["head"]["polarity"] == "positive"
+        if r["strength"] == "strict":
+            L.append(f'{ind}if add({json.dumps(r["head"]["pred"])}, [{args}], {"SP" if pos else "SN"}): grew = True')
+        else:
+            subst = ", ".join(term(a) for a in r["subst"])
+            L.append(f'{ind}cand({json.dumps(r["name"])}, {r["strength"] == "defeater"}, '
+                     f'{json.dumps(r["head"]["pred"])}, {pos}, [{args}], [{subst}])')
+        L.append("    return grew")
+        L.append("")
+    L.append("# Страты строгого слоя §110 (DECISION-0088): каждая — наименьшая неподвижная точка.")
+    L.append("STRICT = [" + ", ".join("[" + ", ".join(f"rule_{n}" for n in s) + "]" for s in plan["strata"]["strict"]) + "]")
+    waiting = _waiting_strata(L, plan, lambda name, strata: f"{name} = [" + ", ".join(
+        "[" + ", ".join(f"rule_{n}" for n in s) + "]" for s in strata) + "]", "#")
+    L.append("")
+    L.append("def strict_closure(strata=STRICT):")
+    L.append("    for stratum in strata:")
+    L.append("        grew = True")
+    L.append("        while grew:")
+    L.append("            grew = any([rule() for rule in stratum])")
+    L.append("")
+    for c in plan.get("closures") or []:
+        d, pr = json.dumps(c["domain"]), json.dumps(c["pred"])
+        L.append(f'# {c["id"]}: замыкание §70 — негатив члену домена без strict/asserted positive-опоры')
+        L.append(f'def {c["name"]}():')
+        if c["window"]:
+            if c["window"].get("start"):
+                L.append(f'    if RT.legal_time() < "{c["window"]["start"]}": return')
+            if c["window"].get("end"):
+                L.append(f'    if RT.legal_time() >= "{c["window"]["end"]}": return')
+        L.append(f"    members = [r for i, r in enumerate(TABLES[{d}]) if mask_status(SUP[{d}][RK[{d}][i]]) == \"TRUE_ONLY\"]")
+        L.append("    for row in members:")
+        L.append(f"        if SUP[{pr}].get(RT.key(row), 0) & SP: continue")
+        L.append(f"        add({pr}, list(row), SN)")
+        L.append("")
+    if "norms" in plan:
+        raise ValueError("NORM_RANKS_UNAVAILABLE")
+    L.append("# Расписание фаз §111, решённое планом.")
+    L.append("def saturate():")
+    if prep:
+        L.append("    prepare()")
+    for ph in plan["schedule"]:
+        kind = ph["phase"]
+        if kind not in PHASES:
+            raise ValueError(f"фаза расписания не поддержана эмиттером: {kind!r}")
+        if kind == "strict":
+            L.append(f"    strict_closure({waiting[tuple(ph['waiting'])]})" if ph.get("waiting") else "    strict_closure()")
+        elif kind == "closure":
+            if not ph.get("policies"):
+                L.append("    # §70: фаза closure зарезервирована (DECISION-0237 F7), политик в срезе нет")
+            for name in ph.get("policies") or []:
+                L.append(f"    {name}()")
+        elif kind == "candidates":
+            L.append(f'    # страта {ph["stratum"]}: кандидаты §111 шаги 2–3')
+            L.append("    CANDS.clear()")
+            for n in ph["rules"]:
+                L.append(f"    rule_{n}()")
+        elif kind == "defeat":
+            L.append("    surviving = defeat()")
+        elif kind == "surviving":
+            L.append("    for urn, row, positive in surviving: add(urn, row, DP if positive else DN)")
+        elif kind == "norms":
+            L.append("    # §135: позиции норм-правил после поражаемого слоя (DECISION-0242 K3)")
+            for n in plan.get("norms") or []:
+                L.append(f"    norm_{n['name']}()")
+        elif kind == "effects":
+            L.append("    materialize_effects()   # §127–§128")
+        else:
+            L.append(f'    # страта {ph["stratum"]}: статус фиксирован, выводится при чтении (§111 шаг 7)')
+    L.append("    pass")
+    L.append("")
+    L.append('def register(urn, row, polarity="positive"):')
+    L.append('    add(urn, row, SP if polarity == "positive" else SN)')
+    L.append("")
+    L.append("# KEY_CONFLICT §45.1/§196: считаются accepted-кортежи — strict/asserted positive-опоры.")
+    L.append("def key_conflicts():")
+    L.append("    n = 0")
+    L.append("    for urn, keys in KEYS.items():")
+    L.append("        rows = [r for i, r in enumerate(TABLES[urn]) if SUP[urn][RK[urn][i]] & SP]")
+    L.append("        for key in keys:")
+    L.append("            groups = {}")
+    L.append("            for row in rows:")
+    L.append("                p = RT.key([row[i] for i in key])")
+    L.append("                groups[p] = groups.get(p, 0) + 1")
+    L.append("            n += sum(1 for c in groups.values() if c > 1)")
+    L.append("    return n")
+    L.append("def key_conflict_predicates():")
+    L.append("    out = set()")
+    L.append("    for urn, keys in KEYS.items():")
+    L.append("        rows = [r for i, r in enumerate(TABLES[urn]) if SUP[urn][RK[urn][i]] & SP]")
+    L.append("        for key in keys:")
+    L.append("            groups = {}")
+    L.append("            for row in rows:")
+    L.append("                p = RT.key([row[i] for i in key]); groups[p] = groups.get(p, 0) + 1")
+    L.append("            if any(c > 1 for c in groups.values()): out.add(urn)")
+    L.append("    return out")
+    L.append("")
+    L.append("# Собственные факты пакета; `reset` возвращает модель к ним (чистое `evaluate` API).")
+    L.append("def package_facts():")
+    for f in plan["facts"]:
+        bit = "SP" if f.get("polarity", "positive") == "positive" else "SN"
+        L.append(f'    add({json.dumps(f["pred"])}, [' + ", ".join(term(a) for a in f["args"]) + f'], {bit})')
+    L.append("    pass")
+    L.append("")
+    L.append("def reset():")
+    L.append("    for urn in TABLES:")
+    L.append("        TABLES[urn].clear(); RK[urn].clear(); SUP[urn].clear()")
+    L.append("    CANDS.clear(); APPLIED.clear()")
+    if _is_09(plan):
+        L.append("    RULE_ISSUES.clear(); _ISSUE_SEEN.clear()")
+        if plan["planVersion"] in (SUPPORTED_PLAN_12, SUPPORTED_PLAN_13, SUPPORTED_PLAN_14, SUPPORTED_PLAN_15, SUPPORTED_PLAN_16, SUPPORTED_PLAN_17, SUPPORTED_PLAN_18, SUPPORTED_PLAN_19):
+            L.append("    _KIND_SEEN.clear()")
+    if "norms" in plan:
+        L.append("    POSITIONS.clear(); BLOCKED.clear(); BLOCKED_IMMUNITY.clear(); NORM_ISSUES.clear(); _NORM_SEEN.clear(); _NORM_SEQ.clear()")
+    L.append("    package_facts()")
+    L.append("")
+    L.append("package_facts()")
+    return _factory("\n".join(L) + "\n", plan)
+
+# --- поверхность API (DECISION-0234) ----------------------------------------
+# Вопрос — pub-отношение с производящим правилом (план решает, какие);
+# вход — эмпирический предикат или предикат без производителя, достижимый
+# из вопросов. Обёртка семантики не несёт: она строит факты, зовёт модель
+# и читает таблицу вопроса — то же, что делает раннер.
+
+def _api(plan: dict) -> dict:
+    return plan.get("api") or {"questions": [], "inputs": []}
+
+
+def _api_words(name: str) -> list:
+    """Слова нейтрального имени API: части между `_` и горбы camelCase с учётом
+    регистра букв Unicode — основа имени на языке цели (DECISION-0423 §2.7)."""
+    words = []
+    for part in name.split("_"):
+        if not part:
+            continue
+        cur = part[0]
+        for prev, ch, nxt in zip(part, part[1:], part[2:] + " "):
+            if ch.isupper() and (prev.islower() or prev.isdigit() or (prev.isupper() and nxt.islower())):
+                words.append(cur)
+                cur = ch
+            else:
+                cur += ch
+        words.append(cur)
+    return words
+
+
+def api_names(entries: list) -> dict:
+    """Нейтральное имя плана → имя функции Python в snake_case. Знаки, которых
+    нет в идентификаторах Python, заменяются `_`; совпадения после
+    преобразования разводятся суффиксом `_2`, `_3` в порядке плана
+    (отсортирован по StableId), поэтому имена детерминированы."""
+    out, used = {}, set()
+    for e in entries:
+        base = "_".join(w.lower() for w in _api_words(e["name"]))
+        base = "".join(c if ("x" + c).isidentifier() else "_" for c in base) or "x"
+        name, n = base, 1
+        while name in used:
+            n += 1
+            name = f"{base}_{n}"
+        used.add(name)
+        out[e["name"]] = name
+    return out
+
+
+def api_doc(entry: dict) -> list:
+    """Строки комментария над функцией API: метки отношения, затем по
+    каждому производящему правилу — его метка и якоря `локатор · редакция`.
+    Текст — из CLIR как есть; комментарий не переводится и не сокращается."""
+    lines = []
+    for l in entry.get("labels", [])[:2]:
+        lines.append(f'{l["text"]} [{l["language"]}, {l["status"]}]')
+    for src in entry.get("sources", []):
+        head = src["rule"]
+        if src["labels"]:
+            head += ": " + src["labels"][0]["text"]
+        lines.append(head)
+        for a in src["anchors"]:
+            where = a.get("locator") or a["id"].split("#")[-1]
+            lines.append("  @source " + where + (f" · {a['edition']}" if a.get("edition") else ""))
+    return lines
+
+
+def emit_api(plan: dict) -> str:
+    """API порождённого модуля (DECISION-0234, DECISION-0423): конструкторы
+    фактов по входам, чистые функции вопросов и реестры по имени. Всё идёт
+    через `api_base` в единый вход `evaluate`, общий с раннером; ответ —
+    `Answer` одной формы у L0 и L1. Над каждой функцией — метки отношения и
+    якоря `@source`."""
+    check_plan(plan)
+    api = _api(plan)
+    negation = "negation" in (plan.get("capabilities") or ())
+    L = ['"""Поверхность API порождённого модуля (DECISION-0234, DECISION-0423).',
+         "",
+         "Факты строятся функциями `fact_*` (и `negated_*` у модели L1) из литерал-термов",
+         "§53 — конструкторов `integer`, `decimal`, `money`, `text`, `date`, `entity` и",
+         "других — либо из значений языка, однозначных по объявленному типу параметра.",
+         "Вопрос `ask_*` — чистая функция: каждый вызов строит своё состояние модели и",
+         "возвращает `Answer` (статус §62, статус вычисления §175, issues, запросы судье).",
+         '"""',
+         "from api_base import (VALUE_FORMAT, Answer, Fact, InputError, Refused, Term, boolean,  # noqa: F401",
+         "                      date, decimal, entity, from_value, instant, integer, member, money,",
+         "                      natural, quantity, rational, text, to_value)",
+         "import api_base as _base", "", ""]
+    inp, qs = api_names(api["inputs"]), api_names(api["questions"])
+    L.append("# Факты: по функции на входной предикат, аргументы — по объявленным типам §189.")
+    for i in api["inputs"]:
+        args = ", ".join(f"a{j}" for j in range(len(i["params"])))
+        sig = f'{json.dumps(i["pred"])}, {tuple(i["params"])!r}, {tuple(i["kinds"])!r}'
+        fn = inp[i["name"]]
+        L.append(f'def fact_{fn}({args}) -> Fact:')
+        doc = api_doc(i)
+        if doc:
+            L.append('    """' + "\n    ".join(doc) + '"""')
+        L.append(f'    return _base.fact({sig}, ({args}{"," if len(i["params"]) == 1 else ""}), "fact_{fn}")')
+        L.append("")
+        if negation:
+            L.append(f'def negated_{fn}({args}) -> Fact:')
+            L.append('    """Отрицательный факт §113 того же входа."""')
+            L.append(f'    return _base.fact({sig}, ({args}{"," if len(i["params"]) == 1 else ""}), "negated_{fn}", negative=True)')
+            L.append("")
+    L.append("")
+    L.append("# Вопросы: статус §62 при данных фактах на дату `on` (правовое время §31).")
+    for q in api["questions"]:
+        params = "".join(f", a{j}" for j in range(len(q["params"])))
+        want = ", ".join(f"a{j}" for j in range(len(q["params"])))
+        tail = "," if len(q["params"]) == 1 else ""
+        fn = qs[q["name"]]
+        L.append(f'def ask_{fn}(facts, on{params}, *, query_id=None) -> Answer:')
+        doc = api_doc(q)
+        if doc:
+            L.append('    """' + "\n    ".join(doc) + '"""')
+        L.append(f'    return _base.ask({json.dumps(q["pred"])}, {tuple(q["params"])!r}, {tuple(q["kinds"])!r}, '
+                 f'facts, on, ({want}{tail}), {json.dumps(q["name"])}, query_id)')
+        L.append("")
+        L.append(f'def rows_{fn}(facts, on, *, query_id=None) -> Answer:')
+        L.append(f'    """Установленные строки `{q["name"]}` литерал-термами §53."""')
+        L.append(f'    return _base.rows({json.dumps(q["pred"])}, facts, on, {json.dumps(q["name"])}, query_id)')
+        L.append("")
+    L.append("")
+    L.append("# Реестры по имени — для обвязки и проверки: вопрос и вход по строке.")
+    L.append("QUESTIONS = {" + ", ".join(f'{json.dumps(q["name"], ensure_ascii=False)}: ask_{qs[q["name"]]}'
+                                         for q in api["questions"]) + "}")
+    L.append("INPUTS = {" + ", ".join(f'{json.dumps(i["name"], ensure_ascii=False)}: fact_{inp[i["name"]]}'
+                                      for i in api["inputs"]) + "}")
+    L.append("NEGATED = {" + (", ".join(f'{json.dumps(i["name"], ensure_ascii=False)}: negated_{inp[i["name"]]}'
+                                        for i in api["inputs"]) if negation else "") + "}")
+    return "\n".join(L) + "\n"
+
+# --- дескриптор цели: раскладка, сборка, запуск ---------------------------
+import shutil as _shutil
+import sys as _sys
+from pathlib import Path as _Path
+
+HERE = _Path(__file__).resolve().parent
+EXT = "py"
+MODEL = "model.py"
+# Минимальная версия тулчейна устанавливаемого пакета (DECISION-0423 §2.7) —
+# версия проверок CI (`.github/workflows/candidate.yml`), а не машины генератора.
+TOOLCHAIN_MIN = "3.13"
+API = "api.py"
+# Виды вопросов, которые исполняет раннер цели; ворота исполняют вектор
+# только когда его вид поддержан ВСЕМИ активными целями.
+QUERY_KINDS = {"truth", "term", "collect"}
+
+
+def available():
+    return True, "интерпретатор запущенного процесса"
+
+MAINS = {"runner": "runner.py", "cert": "cert.py", "apicheck": "apicheck.py"}
+
+
+def layout(proj, main: str) -> list:
+    """Файлы цели в каталоге проекта; модель кладёт вызывающий."""
+    proj = _Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    names = ("runtime.py", MAINS[main]) if main == "cert" else ("runtime.py", "evaluate.py", "api_base.py", MAINS[main])
+    for name in names:
+        _shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    return None
+
+
+def run(proj, main: str):
+    """argv-префикс и cwd; аргументы (дело и вопрос либо фикстура) добавляет вызывающий."""
+    return [_sys.executable, str(_Path(proj) / MAINS[main])], str(proj)
+
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+    import plan as P
+    ir = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    Path(sys.argv[2]).write_text(emit(P.build_plan(ir)), encoding="utf-8")