arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/go/emit.py

@@ -0,0 +1,1806 @@
+#!/usr/bin/env python3
+"""Эмиттер Go. План тот же; отличаются синтаксис и приведение типов."""
+import json
+import re
+
+CAST = {"money": "Money", "dec": "Dec", "text": "string", "bool": "bool", "date": "Date", "enum": "Sym",
+        "rat": "Rational", "qty": "Qty", "inst": "Instant"}
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+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"}}
+
+
+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 _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 _judgments(L: list, plan: dict, l1: bool) -> None:
+    """Отношения суждения §47.3 (DECISION-0274): орган и форма запроса, и доступы
+    модели для обхода запроса судье в рантайме (применения страт, опоры,
+    приоритеты — у L1; у L0 — заглушки)."""
+    L.append("// Отношения суждения §47.3 (DECISION-0274): орган и форма запроса.")
+    L.append("var JUDGMENTS = map[string]judgmentDecl{")
+    for pred, d in sorted((plan.get("judgments") or {}).items()):
+        schema = ("planJSON(" + json.dumps(json.dumps(d["requestSchema"], ensure_ascii=False)) + ")"
+                  if d.get("requestSchema") is not None else "nil")
+        L.append(f"\t{json.dumps(pred)}: {{{json.dumps(d['authority'])}, {schema}}},")
+    L.append("}")
+    L.append("")
+    L.append("func judgmentDecls() map[string]judgmentDecl { return JUDGMENTS }")
+    L.append("")
+    L.append("// Доступы модели для обхода запроса судье в рантайме (DECISION-0274).")
+    L.append("func judgmentModel() jModel {")
+    L.append("\treturn jModel{truthOf, func() map[string][][]Val { return TABLES },")
+    L.append("\t\tfunc() ([]interface{}, map[string]interface{}) { r, c, _, _ := backchainEnv(); return r, c },")
+    L.append("\t\tjudgmentDecls, appliedCands, supportBits, prioHas, judgmentPositions, blockedImmunity, legalTime}")
+    L.append("}")
+    L.append("")
+    if not l1:
+        L.append("func appliedCands() []appliedCand { return nil }")
+        L.append("")
+        L.append("func supportBits(urn string, row []Val) int { return 0 }")
+        L.append("")
+        L.append("func prioHas(a, b string) bool { return false }")
+        L.append("")
+
+
+def _functions(L: list, plan: dict) -> None:
+    """Функции §46 и параметры A3 (DECISION-0273). Функции печатаются
+    функциями цели по позиционным параметрам и доступны раннеру для
+    вопросов `term`; параметр A3 — значение на legalTime из prepare."""
+    L.append("// Функции §46 (DECISION-0273): чистые тела по позиционным параметрам.")
+    for f in plan.get("functions") or []:
+        params = ", ".join(f"a{i} Val" for i in range(len(f["params"])))
+        L.append(f'func f_{f["name"]}({params}) Val {{ return {term(f["body"])} }}')
+    L.append("")
+    L.append("type funcDecl struct {")
+    L.append("\tParams  []string")
+    L.append("\tReturns string")
+    L.append("\tFn      func([]Val) Val")
+    L.append("}")
+    L.append("")
+    L.append("var FUNCTIONS = map[string]funcDecl{")
+    for f in plan.get("functions") or []:
+        call = ", ".join(f"a[{i}]" for i in range(len(f["params"])))
+        params = "[]string{" + ", ".join(json.dumps(x) for x in f["paramTypes"]) + "}"
+        L.append(f'\t{json.dumps(f["id"])}: {{{params}, {json.dumps(f["returnType"])}, '
+                 f'func(a []Val) Val {{ return f_{f["name"]}({call}) }}}},')
+    L.append("}")
+    L.append("")
+    L.append("// Параметры A3 §A3.2: окна [start, end) оси права со значением (пустая строка —")
+    L.append("// бесконечность); активное значение готовит prepare по legalTime, разрыв датасета —")
+    L.append("// MISSING_PARAMETER_VALUE правила.")
+    L.append("var A3_TYPES = map[string]string{" + ", ".join(
+        f'{json.dumps(p["id"])}: {json.dumps(p["type"])}' for p in plan.get("a3Params") or []) + "}")
+    if plan.get("a3Params"):
+        L.append("type a3Window struct {")
+        L.append("\tstart, end string")
+        L.append("\tvalue      Val")
+        L.append("}")
+        L.append("var a3Windows = map[string][]a3Window{")
+        for p in plan["a3Params"]:
+            ws = ", ".join(f'{{{json.dumps(s or "")}, {json.dumps(e or "")}, {term(v)}}}' for s, e, v in p["windows"])
+            L.append(f'\t{json.dumps(p["id"])}: {{{ws}}},')
+        L.append("}")
+        L.append("var a3Active = map[string]Val{}")
+        L.append("")
+        L.append("func a3(id string) Val {")
+        L.append("\tv, ok := a3Active[id]")
+        L.append("\tif !ok {")
+        L.append('\t\tpanic(termError{"MISSING_PARAMETER_VALUE"})')
+        L.append("\t}")
+        L.append("\treturn v")
+        L.append("}")
+    L.append("")
+
+
+def _calendar_env(L: list, plan: dict) -> None:
+    """Окружение календаря (DECISION-0245 п. 3–4) и обход E-0105; у модели
+    без календаря — заглушки для общего раннера."""
+    if "calendars" in plan:
+        L.append("// §85/§86 (DECISION-0245): версия семантики, политики и снимки программы.")
+        L.append(f'var CAL_POLICIES = planJSON({json.dumps(json.dumps(plan["deadlinePolicies"]))}).(map[string]interface{{}})')
+        L.append(f'var CAL_SNAPSHOTS = planSnapshots({json.dumps(json.dumps(plan["calendars"]))})')
+        L.append(f'func calendarEnv() (string, map[string]interface{{}}, []Snapshot, bool) {{ '
+                 f'return {json.dumps(plan["semanticVersion"])}, CAL_POLICIES, CAL_SNAPSHOTS, true }}')
+    else:
+        L.append("func calendarEnv() (string, map[string]interface{}, []Snapshot, bool) { return \"\", nil, nil, false }")
+    if "backchain" in plan and not _is_09(plan):
+        L.append("var issueSeen = map[string]bool{}")
+    if "backchain" in plan:
+        L.append("// E-0105: правила для обхода ошибок терма от цели вопроса.")
+        L.append(f'var BACKCHAIN = planJSON({json.dumps(json.dumps(plan["backchain"]))}).([]interface{{}})')
+        L.append(f'var BACKCHAIN_CONSTS = planJSON({json.dumps(json.dumps(plan["backchainConsts"]))}).(map[string]interface{{}})')
+        L.append("func backchainEnv() ([]interface{}, map[string]interface{}, map[string]bool, bool) { "
+                 "return BACKCHAIN, BACKCHAIN_CONSTS, issueSeen, true }")
+    else:
+        L.append("func backchainEnv() ([]interface{}, map[string]interface{}, map[string]bool, bool) { "
+                 "return nil, nil, nil, false }")
+    L.append("")
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "qty":
+        # Счётчик календарной функции (DECISION-0245 п. 2): число и единица.
+        return f'{t["v"]}, {json.dumps(t["unit"])}'
+
+    if k == "var":
+        # Ячейка вида text не приводится: в слот сущности дело вправе подать
+        # const_ref без объявления (`Sym`), и приведение `.(string)` роняло бы
+        # раннер паникой; функции рантайма принимают Val.
+        if t["t"] == "text":
+            return f'r{t["row"]}[{t["col"]}]'
+        return f'r{t["row"]}[{t["col"]}].({CAST[t["t"]]})'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'money("{t["v"]}", "{t["cur"]}")'
+        if t["t"] == "dec":
+            return f'dec("{t["v"]}")'
+        if t["t"] == "date":
+            return f'date("{t["v"]}")'
+        if t["t"] == "inst":
+            return f'instant("{t["v"]}")'
+        if t["t"] == "enum":
+            return f'sym("{t["v"]}")'
+        if t["t"] == "rat":
+            return f'rat("{t["v"]}")'
+        if t["t"] == "qty":
+            return f'qty("{t["v"]}", {json.dumps(t["unit"], ensure_ascii=False)})'
+        return json.dumps(t["v"], ensure_ascii=False)
+    if k == "bin":
+        if "lk" in t:
+            # DECISION-0252 п. 3: пара §58 решается статическими видами операндов.
+            return f'arith("{t["op"]}", {term(t["l"])}, {term(t["r"])}, "{t["lk"]}", "{t["rk"]}")'
+        return f'{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        if any(a["k"] == "qtyvar" for a in t["args"]):
+            return _counter_call(t)
+        if "ak" in t:
+            # DECISION-0259 п. 2: политика §50 проверяется рантаймом; виды
+            # значения и точности — из плана (последний вид — Text режима).
+            name = "roundMode" if t["fn"] == "round" else "divRound"
+            return (f'{name}(' + ", ".join(term(a) for a in t["args"]) + ", "
+                    + ", ".join(json.dumps(c) for c in t["ak"][:-1]) + ")")
+        return f'{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ")"
+    if k == "param":
+        return f'p{t["i"]}' if t["t"] == "text" else f'p{t["i"]}.({CAST[t["t"]]})'
+    if k == "fvar":
+        # DECISION-0273: параметр функции §46 — позиционный аргумент.
+        return f'a{t["i"]}' if t["t"] == "text" else f'a{t["i"]}.({CAST[t["t"]]})'
+    if k == "lvar":
+        return f'l{t["i"]}' if t["t"] == "text" else f'l{t["i"]}.({CAST[t["t"]]})'
+    if k == "fcall":
+        return f'f_{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ")"
+    if k == "a3":
+        # Параметр A3: значение на legalTime готовит prepare; разрыв — termError.
+        return f'a3({json.dumps(t["id"])})'
+    if k == "let":
+        # §55: значение считается один раз, тело — с локальным связыванием.
+        return f'func(l{t["i"]} Val) Val {{ return {term(t["b"])} }}({term(t["v"])})'
+    if k == "match":
+        # §55.1: первая совпавшая ветвь; ни одна — NON_EXHAUSTIVE_MATCH.
+        parts = [f'func() Val {{ s := {term(t["s"])}; _ = s']
+        for arm in t["arms"]:
+            if arm["m"] is None:
+                parts.append(f'return {term(arm["v"])}')
+                break
+            parts.append(f'if eq(s, sym({json.dumps(arm["m"])})) {{ return {term(arm["v"])} }}')
+        else:
+            parts.append('panic(termError{"NON_EXHAUSTIVE_MATCH"})')
+        return "; ".join(parts) + " }()"
+    if k == "agg":
+        return f'{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ")"
+    if k == "if":
+        # §56 (DECISION-0270): ленивая ветвь — замыкание, у Go тернарного оператора нет.
+        return f'func() Val {{ if {cond(t["c"])} {{ return {term(t["t"])} }}; return {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'cmp({term(c["l"])}, "{c["op"]}", {term(c["r"])})'
+    if k in ("and", "or"):
+        op = " && " if k == "and" else " || "
+        return "(" + op.join(cond(x) for x in c["items"]) + ")"
+    raise AssertionError(k)
+
+
+def _key_scope(L: list, plan: dict) -> None:
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(rule["head"]["pred"])
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(rule["head"]["pred"])
+    L.append("// E-0210/E-0242: forward readers of a keyed relation.")
+    L.append("var KEY_READERS = map[string][]string{")
+    for source, consumers in sorted(readers.items()):
+        L.append(f'\t{json.dumps(source)}: {{' + ", ".join(json.dumps(value) for value in sorted(consumers)) + "},")
+    L.append("}")
+
+
+def _counter_call(t: dict) -> str:
+    """Счётчик-связыватель §86.1 (DECISION-0256 п. 6): `counter` рантайма
+    возвращает число и единицу, а Go не раскрывает пару среди других
+    аргументов — вызов оборачивается замыканием. Порядок вычисления прежний:
+    аргументы слева направо, проверка счётчика — на его месте. Ячейка и
+    параметр не приводятся к Qty: вид проверяет `counter` (TYPE_ERROR)."""
+    out, args = [], []
+    for i, a in enumerate(t["args"]):
+        if a["k"] == "qtyvar":
+            inner = a["term"]
+            if inner["k"] == "var":
+                src = f'r{inner["row"]}[{inner["col"]}]'
+            elif inner["k"] == "param":
+                src = f'p{inner["i"]}'
+            else:
+                src = term(inner)
+            out.append(f'qn{i}, qu{i} := counter({src}, {json.dumps(a["fn"])})')
+            args += [f"qn{i}", f"qu{i}"]
+        else:
+            out.append(f"qa{i} := {term(a)}")
+            args.append(f"qa{i}")
+    return f'func() Date {{ {"; ".join(out)}; return {t["fn"]}({", ".join(args)}) }}()'
+
+
+# Виды ячеек, на которых `eq` рантайма не отказывает: проверку соединения
+# можно поставить на уровень атома, который её связывает, — ответ и отказы
+# прежние, а декартово произведение не строится (у `algo.*` шесть атомов
+# тела давали минуты на пустом деле). Соединение над деньгами отказывает на
+# разных валютах, поэтому при нём правило печатается прежним порядком.
+_EARLY_KINDS = {"text", "enum", "date", "dec"}
+
+
+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 _go_wild_open(L: list, ind: str, i: int, a: dict) -> None:
+    """§98 (DECISION-0268): множество проекций строк атома с `_` — на уровне
+    цикла, то есть заново на каждой подстановке внешних атомов."""
+    if a.get("wild"):
+        L.append(f'{ind}w{i} := map[string]bool{{}}')
+
+
+def _go_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} := key([]Val{{{cells}}})')
+        _block(L, ind, f'if w{i}[wk{i}] {{@continue@}}')
+        L.append(f'{ind}w{i}[wk{i}] = true')
+
+
+def _go_checks(checks: list) -> list:
+    out = []
+    for kind, c in checks:
+        if kind == "join":
+            (ai, aj, _at), (bi, bj, _bt) = c
+            out.append(f'if !cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]) {{@continue@}}')
+        else:
+            out.append(f'if !eq(r{c["row"]}[{c["col"]}], {term(c["term"])}) {{@continue@}}')
+    return out
+
+
+# Хуки экземпляра модели для входа `evaluate` (DECISION-0423 §2.3): поля
+# структуры `Model` в evaluate.go — те же имена и типы.
+GO_HOOKS = ("NODE_IDS", "TABLES", "PARAMS", "CONSTS", "BASES", "FUNCTIONS", "A3_TYPES", "KEY_READERS", "CARRIER_EDGES",
+            "saturate", "register", "registerNegative", "packageFacts", "keyConflicts", "keyConflictPredicates",
+            "truthOf", "establishedRows", "ruleIssues", "normIssues", "normPositions", "blockedEffect",
+            "calendarEnv", "backchainEnv", "judgmentModel", "setStatusTime")
+# Функции рантайма, читающие контекст вычисления: в фабрике их затеняют
+# одноимённые замыкания над контекстом экземпляра.
+GO_CONTEXT_FUNCS = ("legalTime", "add_calendar_period", "add_business_days", "add_legal_term")
+
+
+def _go_body_brace(line: str, start: int) -> int:
+    """Позиция `{`, открывающей тело функции, после списка параметров,
+    начинающегося в `start`: первая ` {` на нулевой глубине скобок (тип
+    результата вроде `map[string]interface{}` пробела перед `{` не несёт)."""
+    depth, i = 0, start
+    while i < len(line):
+        ch = line[i]
+        if ch == '"':
+            i += 1
+            while line[i] != '"':
+                i += 2 if line[i] == "\\" else 1
+        elif ch in "([":
+            depth += 1
+        elif ch in ")]":
+            depth -= 1
+        elif ch == "{" and depth == 0 and line[i - 1] == " ":
+            return i
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+        i += 1
+    raise ValueError("сигнатура функции модели без тела: " + line[:80])
+
+
+def _go_split_sig(sig: str) -> tuple[str, str]:
+    """`(параметры) результат` → (параметры со скобками, результат)."""
+    depth = 0
+    for i, ch in enumerate(sig):
+        depth += ch == "("
+        depth -= ch == ")"
+        if depth == 0:
+            return sig[:i + 1], sig[i + 1:].strip()
+    raise ValueError("параметры функции модели без закрывающей скобки: " + sig[:80])
+
+
+def _factory(src: str, plan: dict) -> str:
+    """Модель — фабрика состояния на вызов (DECISION-0423 §2.3). `package`,
+    импорты, `const` и `type` остаются на уровне пакета; переменные и функции
+    модели становятся локальными переменными и замыканиями `newModel()`, тела
+    правил не переписываются. Порядок внутри фабрики: контекст вычисления и
+    затеняющие замыкания рантайма, объявления функций, переменные в порядке
+    текста (переменная, чей инициализатор зовёт функцию модели, получает тип
+    сразу, а значение — после замыканий), замыкания, отложенные значения, тела
+    `init`. Возвращается `*Model` с хуками для `evaluate`. Правило раскладки
+    эмиттера: объявление верхнего уровня начинается с нулевой колонки."""
+    src += "var NODE_IDS = map[string]bool{" + ", ".join(json.dumps(x) + ": true" for x in (plan.get("admission") or {}).get("reservedAssertionIds", [])) + "}\n"
+    lines = src.rstrip("\n").split("\n")
+    head, top, segs = [], [], []
+    cur = None
+    for ln in lines:
+        if ln.startswith(("func ", "var ", "const ", "type ", "import ")):
+            cur = [ln]
+            segs.append(cur)
+        elif cur is None:
+            head.append(ln)
+        else:
+            cur.append(ln)
+    for seg in segs:
+        for ln in seg:
+            if "`" in ln.split("//")[0]:
+                raise ValueError("сырая строка в модели: фабрика сдвигает отступ — " + ln[:80])
+    funcs = {}
+    for seg in segs:
+        if seg[0].startswith("func ") and not seg[0].startswith("func init()"):
+            name = seg[0][5:seg[0].index("(")]
+            funcs[name] = seg
+    sigs = {}
+    for name, seg in funcs.items():
+        start = 5 + len(name)
+        brace = _go_body_brace(seg[0], start)
+        sigs[name] = seg[0][start:brace].rstrip()
+    def ref(text, name):
+        # Embedded JSON and comments contain names such as "status" too.
+        # Only Go identifiers can depend on a model closure.
+        code = re.sub(r'"(?:\\.|[^"\\])*"|//[^\n]*|/\*.*?\*/', "", text, flags=re.S)
+        return re.search(r"(?<![\w.])" + re.escape(name) + r"\b", code) is not None
+    early, deferred_decl, deferred_set, assigns, inits, names = [], [], [], [], [], []
+    for seg in segs:
+        first = seg[0]
+        if first.startswith("import "):
+            head.extend(seg)
+        elif first.startswith(("const ", "type ")):
+            top.extend(seg)
+        elif first.startswith("var "):
+            m = re.match(r"var ([A-Za-z_]\w*)(.*)$", first)
+            name, rest = m.group(1), m.group(2)
+            if name != "_":
+                names.append(name)
+            text = "\n".join([rest] + seg[1:])
+            called = [f for f in funcs if ref(text, f)]
+            if not called:
+                early.extend("\t" + ln if ln.strip() else "" for ln in seg)
+                continue
+            eq = rest.find("=")
+            typ = rest[:eq].strip() if eq > 0 else ""
+            init = (rest[eq + 1:] if eq >= 0 else "").strip()
+            if not typ:
+                cm = re.match(r"([\w\[\]\*\.]+(?:\([^)]*\))?(?:\s*[\w\[\]\*\.]+)*)\{", init)
+                call = re.match(r"([A-Za-z_]\w*)\(", init)
+                if call and call.group(1) in funcs:
+                    typ = _go_split_sig(sigs[call.group(1)])[1]
+                elif cm:
+                    typ = init[:init.index("{")].strip()
+                if not typ or typ.startswith("(") or "," in typ:
+                    raise ValueError(f"тип отложенной переменной модели не выводится: {name}")
+            deferred_decl.append(f"\tvar {name} {typ}")
+            body = [f"\t{name} = {init}"] + ["\t" + ln if ln.strip() else "" for ln in seg[1:]]
+            deferred_set.extend(body)
+        elif first.startswith("func init()"):
+            # тело init — до закрывающей `}` в нулевой колонке; после неё в
+            # сегменте могут стоять комментарии следующего объявления
+            close = max((k for k, ln in enumerate(seg) if ln == "}"), default=None)
+            if close is None:
+                raise ValueError("тело init без закрывающей скобки в нулевой колонке")
+            inits.append("\t{")
+            inits.extend("\t" + ln if ln.strip() else "" for ln in seg[1:close + 1])
+            inits.extend("\t" + ln if ln.strip() else "" for ln in seg[close + 1:])
+        else:
+            name = first[5:first.index("(")]
+            start = 5 + len(name)
+            brace = _go_body_brace(first, start)
+            names.append(name)
+            assigns.append(f"\t{name} = func{sigs[name]} " + first[brace:])
+            assigns.extend("\t" + ln if ln.strip() else "" for ln in seg[1:])
+    used_ctx = [f for f in GO_CONTEXT_FUNCS if any(ref("\n".join(seg), f) for seg in segs)]
+    out = head + top + ["",
+                        "// DECISION-0423 §2.3: новое состояние модели на одно вычисление.",
+                        "func newModel() *Model {",
+                        "\tctx := &evalContext{}"]
+    out += [f"\t{f} := ctx.{f}" for f in used_ctx]
+    out += [f"\tvar {name} func{sigs[name]}" for name in funcs]
+    out += early + deferred_decl + assigns + deferred_set + inits
+    out += [f"\t_ = {n}" for n in ["ctx"] + used_ctx + names]
+    hooks = [h for h in GO_HOOKS if h in names]
+    out.append("\treturn &Model{ctx: ctx, " + ", ".join(f"{h}: {h}" for h in hooks) + "}")
+    out.append("}")
+    return "\n".join(out) + "\n"
+
+
+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 = ["package main", "", "var TABLES = map[string][][]Val{"]
+    for t in plan["tables"]:
+        L.append(f'\t{json.dumps(t["pred"])}: {{}},')
+    L.append("}")
+    _key_scope(L, plan)
+    L.append("")
+    # The shared runner accepts a decision time for L1 normative positions.
+    # L0 models have no positions, but export the same harmless hook so a
+    # runner may execute either plan family without a generated API gap.
+    L.append("// E-0212 §135.1: L0 has no positions; keep the runner API uniform.")
+    L.append("func setStatusTime(t string) {}")
+    L.append("")
+    L.append("// Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("var PARAMS = map[string][]string{")
+    for t in plan["tables"]:
+        L.append(f'\t{json.dumps(t["pred"])}: {{' + ", ".join(json.dumps(x, ensure_ascii=False) for x in t["params"]) + "},")
+    L.append("}")
+    L.append("")
+    L.append("// Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("type constDecl struct {")
+    L.append("\tType  string")
+    L.append("\tValue Val")
+    L.append("}")
+    L.append("")
+    L.append("var CONSTS = map[string]constDecl{")
+    for cid, c in plan["consts"].items():
+        L.append(f'\t{json.dumps(cid)}: {{{json.dumps(c["type"])}, {term(c["term"])}}},')
+    L.append("}")
+    L.append("")
+    L.append("// Наследование сущностей: подтип подходит параметру базового типа.")
+    _functions(L, plan)
+    _judgments(L, plan, l1=False)
+    _calendar_env(L, plan)
+    L.append("var BASES = map[string]string{")
+    for sub, base in plan["bases"].items():
+        L.append(f'\t{json.dumps(sub)}: {json.dumps(base)},')
+    L.append("}")
+    L.append("")
+    L.append("// Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("var KEYS = map[string][][]int{")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'\t{json.dumps(t["pred"])}: {{' + ", ".join("{" + ", ".join(str(i) for i in k) + "}" for k in t["keys"]) + "},")
+    L.append("}")
+    L.append("")
+    L.append("// E-0243 §181.2: forward predicate dependencies for carrier issues.")
+    L.append("var CARRIER_EDGES = map[string][]string{")
+    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)}: []string{{' + ", ".join(json.dumps(x) for x in dict.fromkeys(deps)) + "},")
+    L.append("}")
+    L.append("")
+    L.append("var seen = map[string]bool{}")
+    L.append("")
+    L.append("func addRow(urn string, row []Val) bool {")
+    L.append('\tk := urn + "#" + key(row)')
+    L.append("\tif seen[k] {")
+    L.append("\t\treturn false")
+    L.append("\t}")
+    L.append("\tseen[k] = true")
+    L.append("\tTABLES[urn] = append(TABLES[urn], row)")
+    L.append("\treturn true")
+    L.append("}")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'// {r["id"]}')
+        L.append(f'func rule_{r["name"]}() bool {{')
+        L.append("\tgrew := false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'\tif legalTime() < "{r["window"]["start"]}" {{\n\t\treturn false\n\t}}')
+            if r["window"].get("end"):
+                L.append(f'\tif legalTime() >= "{r["window"]["end"]}" {{\n\t\treturn false\n\t}}')
+        ind = "\t"
+        # Go запрещает неиспользуемую переменную цикла: если строка таблицы
+        # ни в гарде, ни в голове не встречается, переменная гасится `_ =`.
+        inner: list = []
+        levels, late_joins, late_filters = _early(r)
+        for (ai, aj, _at), (bi, bj, _bt) in late_joins:
+            inner.append(f'if !cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]) {{@continue@}}')
+        for f in late_filters:
+            inner.append(f'if !eq(r{f["row"]}[{f["col"]}], {term(f["term"])}) {{@continue@}}')
+        for g in r["guards"]:
+            inner.append(f'if !cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}) {{@continue@}}')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        inner.append(f'if addRow({json.dumps(r["head"]["pred"])}, []Val{{{args}}}) {{@grew = true@}}')
+        early = {i: _go_checks(levels.get(i, [])) for i in range(len(r["atoms"]))}
+        body_text = "".join(inner) + "".join(x for v in early.values() for x in v)
+        for i, a in enumerate(r["atoms"]):
+            _go_wild_open(L, ind, i, a)
+            L.append(f'{ind}for _, r{i} := range TABLES[{json.dumps(a["pred"])}] {{')
+            ind += "\t"
+            if f"r{i}[" not in body_text:
+                L.append(f'{ind}_ = r{i}')
+            for line in early[i]:
+                _block(L, ind, line)
+            _go_wild(L, ind, i, a)
+        for line in inner:
+            head_line, _, rest = line.partition("@")
+            mid, _, tail = rest.partition("@")
+            L.append(ind + head_line)
+            L.append(ind + "\t" + mid)
+            L.append(ind + tail)
+        for _ in r["atoms"]:
+            ind = ind[:-1]
+            L.append(ind + "}")
+        L.append("\treturn grew")
+        L.append("}")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("func saturate() {")
+    L.append("\tfor grew := true; grew; {")
+    if names:
+        L.append("\t\tgrew = false")
+        for n in names:
+            L.append(f"\t\tif rule_{n}() {{\n\t\t\tgrew = true\n\t\t}}")
+    else:
+        L.append("\t\tgrew = false")
+    L.append("\t}")
+    L.append("}")
+    L.append("")
+    L.append("func register(urn string, row []Val) { addRow(urn, row) }")
+    L.append("")
+    L.append("// Общий с L1 интерфейс раннера (DECISION-0237): слой, установленные строки,")
+    L.append("// статус строки и отказ на отрицательный факт.")
+    L.append('const LAYER = "L0"')
+    L.append("")
+    L.append("func establishedRows(urn string) [][]Val { return TABLES[urn] }")
+    L.append("")
+    L.append("func truthOf(urn string, row []Val) string {")
+    L.append("\tfor _, r := range TABLES[urn] {")
+    L.append("\t\tif len(r) != len(row) {")
+    L.append("\t\t\tcontinue")
+    L.append("\t\t}")
+    L.append("\t\tok := true")
+    L.append("\t\tfor i := range r {")
+    L.append("\t\t\tif !eq(r[i], row[i]) {")
+    L.append("\t\t\t\tok = false")
+    L.append("\t\t\t\tbreak")
+    L.append("\t\t\t}")
+    L.append("\t\t}")
+    L.append("\t\tif ok {")
+    L.append('\t\t\treturn "TRUE_ONLY"')
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append('\treturn "NEITHER"')
+    L.append("}")
+    L.append("")
+    L.append('func registerNegative(urn string, row []Val) { refuse("§113: отрицательный факт вне L0-среза") }')
+    L.append("")
+    L.append("// Ошибок значения агрегатов в правилах у L0-модели нет (DECISION-0239).")
+    L.append("func ruleIssues() []string { return nil }")
+    L.append("")
+    L += NORM_STUBS
+    L.append("// KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("func keyConflicts() int {")
+    L.append("\tn := 0")
+    L.append("\tfor urn, keys := range KEYS {")
+    L.append("\t\tfor _, k := range keys {")
+    L.append("\t\t\tgroups := map[string]int{}")
+    L.append("\t\t\tfor _, row := range TABLES[urn] {")
+    L.append("\t\t\t\tproj := make([]Val, len(k))")
+    L.append("\t\t\t\tfor i, c := range k {")
+    L.append("\t\t\t\t\tproj[i] = row[c]")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t\tgroups[key(proj)]++")
+    L.append("\t\t\t}")
+    L.append("\t\t\tfor _, c := range groups {")
+    L.append("\t\t\t\tif c > 1 {")
+    L.append("\t\t\t\t\tn++")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t}")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("\treturn n")
+    L.append("}")
+    L.append("func keyConflictPredicates() map[string]bool {")
+    L.append("\tout := map[string]bool{}")
+    L.append("\tfor urn, keys := range KEYS { for _, k := range keys { groups := map[string]int{}; for _, row := range TABLES[urn] { proj := make([]Val, len(k)); for i, c := range k { proj[i] = row[c] }; groups[key(proj)]++ }; for _, count := range groups { if count > 1 { out[urn] = true } } } }")
+    L.append("\treturn out")
+    L.append("}")
+    L.append("")
+    L.append("// Собственные факты пакета; reset возвращает модель к ним (чистое Evaluate API).")
+    L.append("func packageFacts() {")
+    for f in plan["facts"]:
+        L.append(f'\taddRow({json.dumps(f["pred"])}, []Val{{' + ", ".join(term(a) for a in f["args"]) + "})")
+    L.append("}")
+    L.append("")
+    L.append("func reset() {")
+    L.append("\tfor urn := range TABLES {")
+    L.append("\t\tTABLES[urn] = TABLES[urn][:0]")
+    L.append("\t}")
+    L.append("\tseen = map[string]bool{}")
+    L.append("\tpackageFacts()")
+    L.append("}")
+    return _factory("\n".join(L) + "\n", plan)
+
+# --- поражаемый слой L1 (DECISION-0237) ---------------------------------------
+# Та же печать, что у Python и TypeScript: опоры битами происхождения на ключ
+# строки, кандидаты с идентичностью «правило + подстановка», defeat —
+# локальный helper над полным снимком кандидатов, страты и фазы §111 — из плана.
+
+def _accepts(expr: str, accept: list) -> str:
+    return f"!accepts({expr}, " + ", ".join(json.dumps(a) for a in accept) + ")"
+
+
+def _block(L: list, ind: str, line: str) -> None:
+    """Однострочная запись `if cond {@тело@}` в три строки Go."""
+    head_line, _, rest = line.partition("@")
+    mid, _, tail = rest.partition("@")
+    L.append(ind + head_line)
+    L.append(ind + "\t" + mid)
+    L.append(ind + tail)
+
+
+def _steps09(L: list, body: dict, ind: str) -> tuple:
+    """Шаги тела плана 0.9 в порядке `solve` (как у Python)."""
+    L.append(f"{ind}for once := 0; once < 1; once++ {{")
+    ind += "\t"
+    depth = 1
+    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}{name}, code{name} := tryRow(func() []Val {{ return []Val{{{term(f["term"])}}} }})')
+                        L.append(f'{ind}if code{name} != "" {{')
+                        L.append(f'{ind}\tcodes[code{name}] = true')
+                        L.append(f'{ind}\tcontinue')
+                        L.append(f'{ind}}}')
+                    else:
+                        L.append(f'{ind}{name} := []Val{{{term(f["term"])}}}')
+            _go_wild_open(L, ind, i, a)
+            L.append(f'{ind}for i{i}, r{i} := range TABLES[{p}] {{')
+            ind += "\t"
+            depth += 1
+            L.append(f"{ind}_ = r{i}")
+            _block(L, ind, f'if {_accepts(f"maskStatus(SUP[{p}][RK[{p}][i{i}]])", a["accept"])} {{@continue@}}')
+            for (ai, aj, _at), (bi, bj, _bt) in body["joins"]:
+                if bi == i:
+                    _block(L, ind, f'if !cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]) {{@continue@}}')
+            for f in body["filters"]:
+                if f["row"] == i:
+                    value = f'pre{i}_{f["col"]}[0]' if f.get("pre") else term(f["term"])
+                    _block(L, ind, f'if !eq(r{f["row"]}[{f["col"]}], {value}) {{@continue@}}')
+            _go_wild(L, ind, i, a)
+        elif "check" in step:
+            c = body["checks"][step["check"]]
+            args = ", ".join(term(a) for a in c["args"])
+            predicate = json.dumps(c["pred"])
+            if c.get("err"):
+                # DECISION-0270: ошибка значения аргумента проверки — код по подстановке.
+                ci = step["check"]
+                L.append(f'{ind}a{ci}, codeA{ci} := tryRow(func() []Val {{ return []Val{{{args}}} }})')
+                L.append(f'{ind}if codeA{ci} != "" {{')
+                L.append(f'{ind}\tcodes[codeA{ci}] = true')
+                L.append(f'{ind}\tcontinue')
+                L.append(f'{ind}}}')
+                _block(L, ind, f'if {_accepts(f"truthOf({predicate}, a{ci})", c["accept"])} {{@continue@}}')
+            else:
+                _block(L, ind, f'if {_accepts(f"truthOf({predicate}, []Val{{{args}}})", c["accept"])} {{@continue@}}')
+        else:
+            gi = step["guard"]
+            g = body["guards"][gi]
+            if g.get("cal") or g.get("err"):
+                # DECISION-0245 п. 6, DECISION-0252 п. 4: код ошибки значения — по подстановкам.
+                L.append(f'{ind}ok{gi}, code{gi} := tryBool(func() bool {{ return cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}) }})')
+                L.append(f'{ind}if code{gi} != "" {{')
+                L.append(f'{ind}\tcodes[code{gi}] = true')
+                L.append(f'{ind}\tcontinue')
+                L.append(f'{ind}}}')
+                _block(L, ind, f'if !ok{gi} {{@continue@}}')
+            else:
+                _block(L, ind, f'if !cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])}) {{@continue@}}')
+    return ind, depth
+
+
+def _close09(L: list, ind: str, depth: int) -> None:
+    for _ in range(depth):
+        ind = ind[:-1]
+        L.append(ind + "}")
+
+
+def _aggregates09(L: list, plan: dict) -> None:
+    for a in plan.get("aggregates") or []:
+        params = ", ".join(f"p{i} Val" for i in range(len(a["params"])))
+        call = ", ".join(f"p{i}" for i in range(len(a["params"])))
+        L.append(f'func items_{a["name"]}({params}) []Val {{')
+        L.append("\titems := []Val{}")
+        L.append("\tseen := map[string]bool{}")
+        ind, depth = _steps09(L, a, "\t")
+        L.append(f'{ind}var v Val = {term(a["element"])}')
+        if a["distinct"]:
+            L.append(f"{ind}k := key([]Val{{v}})")
+            L.append(f"{ind}if seen[k] {{")
+            L.append(f"{ind}\tcontinue")
+            L.append(f"{ind}}}")
+            L.append(f"{ind}seen[k] = true")
+        L.append(f"{ind}items = append(items, v)")
+        _close09(L, ind, depth)
+        L.append("\t_ = seen")
+        L.append("\treturn items")
+        L.append("}")
+        L.append("")
+        L.append(f'func {a["name"]}({params}) Val {{')
+        L.append(f'\titems := items_{a["name"]}({call})')
+        if a["op"] == "count":
+            L.append("\treturn dec(strconv.Itoa(len(items)))")
+        else:
+            L.append("\tif len(items) == 0 {")
+            if a["empty"] is not None:
+                L.append(f'\t\treturn {term(a["empty"])}')
+            else:
+                L.append('\t\tpanic(aggError{"EMPTY_AGGREGATE"})')
+            L.append("\t}")
+            if a["op"] == "only":
+                # §51 (errata E-0256): единственное РАЗЛИЧНОЕ значение по ключу.
+                L.append("\tdistinct := map[string]bool{}")
+                L.append("\tfor _, x := range items {")
+                L.append("\t\tdistinct[key([]Val{x})] = true")
+                L.append("\t}")
+                L.append("\tif len(distinct) > 1 {")
+                L.append('\t\tpanic(aggError{"CARDINALITY_CONFLICT"})')
+                L.append("\t}")
+                L.append("\treturn items[0]")
+            else:
+                fn = {"sum": "add", "min": "min", "max": "max"}[a["op"]]
+                L.append("\tacc := items[0]")
+                L.append("\tfor _, x := range items[1:] {")
+                L.append(f"\t\tacc = {fn}(acc, x)")
+                L.append("\t}")
+                L.append("\treturn acc")
+        L.append("}")
+        L.append("")
+        L.append("// E-0116: отрицательное слагаемое под монотонным гардом sum")
+        L.append(f'func neg_{a["name"]}({params}) bool {{')
+        L.append(f'\tfor _, x := range items_{a["name"]}({call}) {{')
+        L.append('\t\tif cmp(x, "lt", sub(x, x)) {')
+        L.append("\t\t\treturn true")
+        L.append("\t\t}")
+        L.append("\t}")
+        L.append("\treturn false")
+        L.append("}")
+        L.append("")
+
+
+def _rule09(L: list, r: dict, value: bool = False) -> None:
+    """Правило плана 0.9: фоллибельное копит выводы и применяет их без ошибки.
+    `value` — план 0.12 (DECISION-0252): ошибки значения §58 и сверка вида."""
+    L.append(f'// {r["id"]} ({r["strength"]})')
+    L.append(f'func rule_{r["name"]}() bool {{')
+    L.append("\tgrew := false")
+    if r["window"]:
+        if r["window"].get("start"):
+            L.append(f'\tif legalTime() < "{r["window"]["start"]}" {{\n\t\treturn false\n\t}}')
+        if r["window"].get("end"):
+            L.append(f'\tif legalTime() >= "{r["window"]["end"]}" {{\n\t\treturn false\n\t}}')
+    L.append("\tout := [][2][]Val{}")
+    L.append("\tfailed := false")
+    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("\tcodes, hcodes := map[string]bool{}, map[string]bool{}")
+    L.append("\tfunc() {")
+    L.append("\t\tdefer func() {")
+    L.append("\t\t\tif rec := recover(); rec != nil {")
+    L.append("\t\t\t\tif e, ok := rec.(aggError); ok {")
+    L.append(f'\t\t\t\t\tissue({json.dumps(r["name"])}, e.code)')
+    L.append("\t\t\t\t\tfailed = true")
+    L.append("\t\t\t\t\treturn")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t\tpanic(rec)")
+    L.append("\t\t\t}")
+    L.append("\t\t}()")
+    ind, depth = _steps09(L, r, "\t\t")
+    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}\tissue({json.dumps(r["name"])}, "MONOTONE_GUARD_NEGATIVE_ADDEND")')
+        L.append(f"{ind}\tcontinue")
+        L.append(f"{ind}}}")
+    args = ", ".join(term(a) for a in r["head"]["args"])
+    subst = ", ".join(term(a) for a in r["subst"])
+    if r.get("headFallible"):
+        if r.get("headAgg"):
+            # Ошибка агрегата головы — ошибка этой подстановки, как ошибка терма (errata E-0265).
+            L.append(f"{ind}row, hcode := tryRow(func() []Val {{")
+            L.append(f"{ind}\tdefer func() {{")
+            L.append(f"{ind}\t\tif rec := recover(); rec != nil {{")
+            L.append(f"{ind}\t\t\tif e, ok := rec.(aggError); ok {{")
+            L.append(f"{ind}\t\t\t\tpanic(termError{{e.code}})")
+            L.append(f"{ind}\t\t\t}}")
+            L.append(f"{ind}\t\t\tpanic(rec)")
+            L.append(f"{ind}\t\t}}")
+            L.append(f"{ind}\t}}()")
+            L.append(f"{ind}\treturn []Val{{{args}}}")
+            L.append(f"{ind}}})")
+        else:
+            L.append(f"{ind}row, hcode := tryRow(func() []Val {{ return []Val{{{args}}} }})")
+        L.append(f'{ind}if hcode != "" {{')
+        L.append(f"{ind}\thcodes[hcode] = true")
+        L.append(f"{ind}\tcontinue")
+        L.append(f"{ind}}}")
+    elif r.get("kindChecks"):
+        L.append(f"{ind}row := []Val{{{args}}}")
+    for pos, want in r.get("kindChecks") or []:
+        # E-0077 (DECISION-0252 п. 5): вид значения против слота — вывод не принят.
+        L.append(f'{ind}if kindOf(row[{pos}]) != "{want}" {{')
+        L.append(f'{ind}\tkindIssue({json.dumps(r["name"])}, {json.dumps(r["head"]["pred"])}, {pos}, row[{pos}])')
+        L.append(f"{ind}\tcontinue")
+        L.append(f"{ind}}}")
+    if r.get("headFallible") or r.get("kindChecks"):
+        L.append(f"{ind}out = append(out, [2][]Val{{row, {{{subst}}}}})")
+    else:
+        L.append(f"{ind}out = append(out, [2][]Val{{{{{args}}}, {{{subst}}}}})")
+    _close09(L, ind, depth)
+    L.append("\t}()")
+    L.append("\tif failed {")
+    L.append("\t\treturn false")
+    L.append("\t}")
+    if cal:
+        name = json.dumps(r["name"])
+        L.append("\t// §58: ошибка гарда снимает правило на проход; ошибка головы снимает только")
+        L.append("\t// свою подстановку, issue — по каждому коду однажды (errata E-0265).")
+        what, why = ("значения", "DECISION-0252 п. 4") if value else ("календаря", "DECISION-0245 п. 6")
+        L.append("\tif len(codes) > 0 {")
+        L.append("\t\tif len(codes) > 1 {")
+        L.append(f'\t\t\trefuse("коды ошибок {what} в гарде зависят от порядка подстановок ({why}): " + {name})')
+        L.append("\t\t}")
+        L.append("\t\tfor c := range codes {")
+        L.append(f"\t\t\tissue({name}, c)")
+        L.append("\t\t}")
+        L.append("\t\treturn false")
+        L.append("\t}")
+        L.append("\thkeys := make([]string, 0, len(hcodes))")
+        L.append("\tfor c := range hcodes {")
+        L.append("\t\thkeys = append(hkeys, c)")
+        L.append("\t}")
+        L.append("\tsort.Strings(hkeys)")
+        L.append("\tfor _, c := range hkeys {")
+        L.append(f"\t\tissue({name}, c)")
+        L.append("\t}")
+    pos = r["head"]["polarity"] == "positive"
+    L.append("\tfor _, o := range out {")
+    if r["strength"] == "strict":
+        L.append(f'\t\tif addRow({json.dumps(r["head"]["pred"])}, o[0], {"bitSP" if pos else "bitSN"}) {{')
+        L.append("\t\t\tgrew = true")
+        L.append("\t\t}")
+    else:
+        L.append(f'\t\tcand({json.dumps(r["name"])}, {str(r["strength"] == "defeater").lower()}, '
+                 f'{json.dumps(r["head"]["pred"])}, {str(pos).lower()}, o[0], o[1])')
+    L.append("\t}")
+    L.append("\treturn grew")
+    L.append("}")
+    L.append("")
+
+
+def _closures09(L: list, plan: dict) -> None:
+    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'func {c["name"]}() {{')
+        if c["window"]:
+            if c["window"].get("start"):
+                L.append(f'\tif legalTime() < "{c["window"]["start"]}" {{\n\t\treturn\n\t}}')
+            if c["window"].get("end"):
+                L.append(f'\tif legalTime() >= "{c["window"]["end"]}" {{\n\t\treturn\n\t}}')
+        L.append("\tmembers := [][]Val{}")
+        L.append(f"\tfor i, row := range TABLES[{d}] {{")
+        L.append(f'\t\tif maskStatus(SUP[{d}][RK[{d}][i]]) == "TRUE_ONLY" {{')
+        L.append("\t\t\tmembers = append(members, row)")
+        L.append("\t\t}")
+        L.append("\t}")
+        L.append("\tfor _, row := range members {")
+        L.append(f"\t\tif SUP[{pr}][key(row)]&bitSP != 0 {{")
+        L.append("\t\t\tcontinue")
+        L.append("\t\t}")
+        L.append(f"\t\taddRow({pr}, append([]Val{{}}, row...), bitSN)")
+        L.append("\t}")
+        L.append("}")
+        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
+
+# Интерфейс позиций для раннера (DECISION-0242): у модели без норм — заглушки;
+# раннер печатает канонический JSON сам, модель его функций не зовёт (харнесс
+# API собирается без раннера).
+NORM_TYPES = [
+    "type normValue struct {", "\tV    Val", "\tPred string", "\tCol  int", "}", "",
+]
+NORM_STUBS = NORM_TYPES + [
+    "type normPosition struct {", "\tTemplate, Modality, Status, Holder string", "\tBeneficiary *string",
+    "\tPayload     interface{}", "\tVars        []string", "\tValues      []normValue", "}", "",
+    "func normPositions() ([]normPosition, bool) { return nil, false }", "",
+    "func normIssues() []string { return nil }", "",
+    "func blockedEffect(pred string, row []Val) bool { return false }", "",
+    "func judgmentPositions() []jPos { return nil }", "",
+    "func blockedImmunity(pred string, row []Val) bool { return false }", "",
+]
+
+
+def _gv(t, rule: str = "") -> str:
+    if t is None:
+        return "nil"
+    if t["k"] == "calbound":
+        # DECISION-0245 п. 8: ошибка границы — issue правила и граница «нет».
+        if "error" in t:
+            return f'boundError({json.dumps(rule)}, {json.dumps(t["error"])})'
+        return f'bound({json.dumps(rule)}, func() Val {{ return {term(t["term"])} }})'
+
+    if t["k"] == "fallback":
+        return '"<fallback>"'
+    if t["k"] == "inf":
+        return json.dumps(t["v"])
+    return term(t)
+
+
+def _gl(t) -> str:
+    if t is None:
+        return "nil"
+    return (f'&nLit{{{json.dumps(t["pred"])}, {str(t["polarity"] == "positive").lower()}, []Val{{'
+            + ", ".join(term(a) for a in t["args"]) + "}}")
+
+
+def _gw(w, rule: str = "") -> str:
+    if w is None:
+        return "nil"
+    return (f'&nWin{{{_gv(w["start"], rule)}, {_gv(w["end"], rule)}, {str(w["startInclusive"]).lower()}, '
+            f'{str(w["endInclusive"]).lower()}}}')
+
+
+def emit_l1(plan: dict) -> str:
+    L = ["package main", "",
+         "// Модель поражаемого слоя L1 (DECISION-0237): опоры с происхождением,",
+         "// кандидаты и defeat по стратам §111; статус §62 выводится при чтении.",
+         "", 'import "sort"', "", 'const LAYER = "L1"', "", "var TABLES = map[string][][]Val{"]
+    v10 = "norms" in plan
+    v09 = _is_09(plan)
+    if v10:
+        L[L.index('import "sort"')] = 'import (\n\t"encoding/json"\n\t"sort"\n\t"strconv"\n\t"strings"\n)'
+    elif v09:
+        L[L.index('import "sort"')] = 'import (\n\t"sort"\n\t"strconv"\n)'
+
+    for t in plan["tables"]:
+        L.append(f'\t{json.dumps(t["pred"])}: {{}},')
+    L.append("}")
+    _key_scope(L, plan)
+    L.append("")
+    if not v10:
+        # L1 without normative positions shares runner.go with normative L1.
+        # It has no status clock but must keep the generated runner API.
+        L.append("// E-0212 §135.1: this L1 model has no normative positions.")
+        L.append("func setStatusTime(t string) {}")
+        L.append("")
+    L.append("// Ключи строк — параллельно строкам; опоры — биты на ключ строки.")
+    L.append("var RK = map[string][]string{}")
+    L.append("var SUP = map[string]map[string]int{}")
+    L.append("")
+    L.append("func init() {")
+    L.append("\tfor urn := range TABLES {")
+    L.append("\t\tRK[urn] = []string{}")
+    L.append("\t\tSUP[urn] = map[string]int{}")
+    L.append("\t}")
+    L.append("}")
+    L.append("")
+    L.append("var CARRIER_EDGES = map[string][]string{")
+    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)}: []string{{' + ", ".join(json.dumps(x) for x in dict.fromkeys(deps)) + "},")
+    L.append("}")
+    L.append("")
+    L.append("// strict/asserted +/−, surviving defeasible +/−")
+    L.append("const (")
+    L.append("\tbitSP = 1")
+    L.append("\tbitSN = 2")
+    L.append("\tbitDP = 4")
+    L.append("\tbitDN = 8")
+    L.append(")")
+    L.append("")
+    L.append("// Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("var PARAMS = map[string][]string{")
+    for t in plan["tables"]:
+        L.append(f'\t{json.dumps(t["pred"])}: {{' + ", ".join(json.dumps(x, ensure_ascii=False) for x in t["params"]) + "},")
+    L.append("}")
+    L.append("")
+    L.append("// Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("type constDecl struct {")
+    L.append("\tType  string")
+    L.append("\tValue Val")
+    L.append("}")
+    L.append("")
+    L.append("var CONSTS = map[string]constDecl{")
+    for cid, c in plan["consts"].items():
+        L.append(f'\t{json.dumps(cid)}: {{{json.dumps(c["type"])}, {term(c["term"])}}},')
+    L.append("}")
+    L.append("")
+    L.append("// Наследование сущностей: подтип подходит параметру базового типа.")
+    _functions(L, plan)
+    _judgments(L, plan, l1=True)
+    _calendar_env(L, plan)
+    L.append("var BASES = map[string]string{")
+    for sub, base in plan["bases"].items():
+        L.append(f'\t{json.dumps(sub)}: {json.dumps(base)},')
+    L.append("}")
+    L.append("")
+    L.append("// Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("var KEYS = map[string][][]int{")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'\t{json.dumps(t["pred"])}: {{' + ", ".join("{" + ", ".join(str(i) for i in k) + "}" for k in t["keys"]) + "},")
+    L.append("}")
+    L.append("")
+    L.append("func addRow(urn string, row []Val, bit int) bool {")
+    L.append("\tk := key(row)")
+    L.append("\tsup := SUP[urn]")
+    L.append("\tm, ok := sup[k]")
+    L.append("\tif !ok {")
+    L.append("\t\tsup[k] = bit")
+    L.append("\t\tTABLES[urn] = append(TABLES[urn], row)")
+    L.append("\t\tRK[urn] = append(RK[urn], k)")
+    L.append("\t\treturn true")
+    L.append("\t}")
+    L.append("\tif m&bit != 0 {")
+    L.append("\t\treturn false")
+    L.append("\t}")
+    L.append("\tsup[k] = m | bit")
+    L.append("\treturn true")
+    L.append("}")
+    L.append("")
+    L.append("// §62: пара опор (t, f) → статус; опоры — объединение strict и surviving.")
+    L.append("func maskStatus(m int) string {")
+    L.append("\tpos, neg := m&(bitSP|bitDP) != 0, m&(bitSN|bitDN) != 0")
+    L.append("\tswitch {")
+    L.append("\tcase pos && neg:")
+    L.append('\t\treturn "BOTH"')
+    L.append("\tcase pos:")
+    L.append('\t\treturn "TRUE_ONLY"')
+    L.append("\tcase neg:")
+    L.append('\t\treturn "FALSE_ONLY"')
+    L.append("\t}")
+    L.append('\treturn "NEITHER"')
+    L.append("}")
+    L.append("")
+    L.append("func accepts(s string, allowed ...string) bool {")
+    L.append("\tfor _, a := range allowed {")
+    L.append("\t\tif s == a {")
+    L.append("\t\t\treturn true")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("\treturn false")
+    L.append("}")
+    L.append("")
+    L.append("func truthOf(urn string, row []Val) string {")
+    L.append("\tsup, ok := SUP[urn]")
+    L.append("\tif !ok {")
+    L.append('\t\treturn "NEITHER"')
+    L.append("\t}")
+    L.append("\treturn maskStatus(sup[key(row)])")
+    L.append("}")
+    L.append("")
+    L.append("// Установленные строки (TRUE_ONLY) — перечисление collect и API, без BOTH.")
+    L.append("func establishedRows(urn string) [][]Val {")
+    L.append("\tout := [][]Val{}")
+    L.append("\tfor i, r := range TABLES[urn] {")
+    L.append('\t\tif maskStatus(SUP[urn][RK[urn][i]]) == "TRUE_ONLY" {')
+    L.append("\t\t\tout = append(out, r)")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("\treturn out")
+    L.append("}")
+    L.append("")
+    if v09:
+        L.append("// Ошибка значения агрегата в правиле (DECISION-0239 G3): issue по правилу и коду однажды.")
+        L.append("type aggError struct{ code string }")
+        L.append("")
+        L.append("var RULE_ISSUES = []string{}")
+        L.append("var issueSeen = map[string]bool{}")
+        L.append("")
+        L.append("func issue(rule, code string) {")
+        L.append('	k := rule + "|" + code')
+        L.append("	if !issueSeen[k] {")
+        L.append("		issueSeen[k] = true")
+        L.append("		RULE_ISSUES = append(RULE_ISSUES, code)")
+        L.append("	}")
+        L.append("}")
+        L.append("")
+        L.append("func ruleIssues() []string { return RULE_ISSUES }")
+        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("var kindSeen = map[string]bool{}")
+            L.append("")
+            L.append("func kindIssue(rule, pred string, pos int, v Val) {")
+            L.append('\tk := rule + "\\x00" + pred + "\\x00" + strconv.Itoa(pos) + "\\x00" + kindOf(v)')
+            L.append("\tif !kindSeen[k] {")
+            L.append("\t\tkindSeen[k] = true")
+            L.append('\t\tissue(rule, "TYPE_ERROR")')
+            L.append("\t}")
+            L.append("}")
+            L.append("")
+        L.append("// strconv нужен только агрегату count; у плана без него импорт иначе мёртв.")
+        L.append("var _ = strconv.Itoa")
+        L.append("")
+        _aggregates09(L, plan)
+    else:
+        L.append("func ruleIssues() []string { return nil }")
+        L.append("")
+    L.append("// Кандидаты §104 страты: идентичность — правило и типизированная подстановка.")
+    L.append("type candidate struct {")
+    L.append("\trule     string")
+    L.append("\tdefeater bool")
+    L.append("\turn      string")
+    L.append("\tpositive bool")
+    L.append("\trow      []Val")
+    L.append("\tkey      string")
+    L.append("}")
+    L.append("")
+    L.append("var cands = map[string]candidate{}")
+    L.append("")
+    L.append("func cand(rule string, defeater bool, urn string, positive bool, row []Val, subst []Val) {")
+    L.append('\tk := rule + "|" + key(subst)')
+    L.append("\tif _, ok := cands[k]; !ok {")
+    L.append("\t\tcands[k] = candidate{rule, defeater, urn, positive, row, key(row)}")
+    L.append("\t}")
+    L.append("}")
+    L.append("")
+    L.append("// Приоритет §106: транзитивное замыкание безусловных рёбер «выше>ниже».")
+    L.append("var PRIO = map[string]bool{" + ", ".join(json.dumps(f"{a}>{b}") + ": true" for a, b in plan["priorities"]) + "}")
+    dated = "datedPriorities" in plan
+    prep = dated or bool(plan.get("a3Params"))
+    if prep:
+        L.append("")
+        L.append("type window struct{ start, end string }")
+        L.append("")
+        L.append("func inWindow(w window, t string) bool {")
+        L.append('\treturn (w.start == "" || t >= w.start) && (w.end == "" || t < w.end)')
+        L.append("}")
+    if dated:
+        L.append("")
+        L.append("// DECISION-0269: датированные рёбра §92.3 — окна [start, end) оси права (пустая строка —")
+        L.append("// бесконечность); активное множество готовится один раз на дело по legalTime (prepare).")
+        L.append("type datedEdge struct {")
+        L.append("\tpair    string")
+        L.append("\twindows []window")
+        L.append("}")
+        L.append("var datedPrio = []datedEdge{" + ", ".join(
+            "{" + json.dumps(f"{a}>{b}") + ", []window{" + ", ".join(
+                "{" + json.dumps(w[0] or "") + ", " + json.dumps(w[1] or "") + "}" for w in ws) + "}}"
+            for a, b, ws in plan["datedPriorities"]) + "}")
+        L.append("var prioActive = map[string]bool{}")
+        L.append("")
+        L.append("func activeEdges(base map[string]bool, dated []datedEdge, t string) map[string]bool {")
+        L.append("\tout := map[string]bool{}")
+        L.append("\tfor k := range base {")
+        L.append("\t\tout[k] = true")
+        L.append("\t}")
+        L.append("\tfor _, e := range dated {")
+        L.append("\t\tfor _, w := range e.windows {")
+        L.append("\t\t\tif inWindow(w, t) {")
+        L.append("\t\t\t\tout[e.pair] = true")
+        L.append("\t\t\t\tbreak")
+        L.append("\t\t\t}")
+        L.append("\t\t}")
+        L.append("\t}")
+        L.append("\treturn out")
+        L.append("}")
+        L.append("")
+    if prep:
+        L.append("func prepare() {")
+        L.append("\tt := legalTime()")
+        L.append("\t_ = t")
+    if dated:
+        L.append("\tprioActive = activeEdges(PRIO, datedPrio, t)")
+        if "datedNormPriorities" in plan:
+            L.append("\tnormPrioActive = activeEdges(normPrio, datedNormPrio, t)")
+    if plan.get("a3Params"):
+        L.append("\t// DECISION-0273: значение параметра A3 на legalTime (подготовленный контекст).")
+        L.append("\ta3Active = map[string]Val{}")
+        L.append("\tfor id, ws := range a3Windows {")
+        L.append("\t\tfor _, w := range ws {")
+        L.append("\t\t\tif inWindow(window{w.start, w.end}, t) {")
+        L.append("\t\t\t\ta3Active[id] = w.value")
+        L.append("\t\t\t}")
+        L.append("\t\t}")
+        L.append("\t}")
+    if prep:
+        L.append("}")
+    prio = "prioActive" if dated else "PRIO"
+    L.append("")
+    L.append("// Defeat §107 по ПОЛНОМУ снимку кандидатов страты; группа — ground-кортеж,")
+    L.append("// побеждённые не удаляются по ходу обхода. Возвращает выживших §108 в")
+    L.append("// порядке ключей: обход map в Go случаен, а порядок обязан быть устойчивым.")
+    L.append("// DECISION-0274: применения страт для пути запроса судье — дефитеры, давшие")
+    L.append("// применение (E-0103), и поражённые/уцелевшие поражаемые кандидаты (E-0100).")
+    L.append("var applied []appliedCand")
+    L.append("")
+    L.append("func appliedCands() []appliedCand { return applied }")
+    L.append("")
+    L.append("func supportBits(urn string, row []Val) int {")
+    L.append("\tm, ok := SUP[urn]")
+    L.append("\tif !ok {")
+    L.append("\t\treturn 0")
+    L.append("\t}")
+    L.append("\treturn m[key(row)]")
+    L.append("}")
+    L.append("")
+    L.append(f'func prioHas(a, b string) bool {{ return {prio}[a+">"+b] }}')
+    L.append("")
+    L.append("func defeat() []candidate {")
+    L.append("\tids := make([]string, 0, len(cands))")
+    L.append("\tfor k := range cands {")
+    L.append("\t\tids = append(ids, k)")
+    L.append("\t}")
+    L.append("\tsort.Strings(ids)")
+    L.append("\tgroups := map[string][]candidate{}")
+    L.append("\torder := []string{}")
+    L.append("\tfor _, id := range ids {")
+    L.append("\t\tc := cands[id]")
+    L.append('\t\tg := c.urn + "\\x00" + c.key')
+    L.append("\t\tif _, ok := groups[g]; !ok {")
+    L.append("\t\t\torder = append(order, g)")
+    L.append("\t\t}")
+    L.append("\t\tgroups[g] = append(groups[g], c)")
+    L.append("\t}")
+    L.append("\tout := []candidate{}")
+    L.append("\tsurvived := map[string]bool{}")
+    L.append("\tfor _, gk := range order {")
+    L.append("\t\tg := groups[gk]")
+    L.append("\t\tfor _, c := range g {")
+    L.append("\t\t\tif c.defeater {")
+    L.append("\t\t\t\tcontinue")
+    L.append("\t\t\t}")
+    L.append("\t\t\t// §107.1: strict/asserted опора комплемента побеждает безусловно")
+    L.append("\t\t\topp := bitSP")
+    L.append("\t\t\tif c.positive {")
+    L.append("\t\t\t\topp = bitSN")
+    L.append("\t\t\t}")
+    L.append("\t\t\tif SUP[c.urn][c.key]&opp != 0 {")
+    L.append("\t\t\t\tcontinue")
+    L.append("\t\t\t}")
+    L.append("\t\t\tbeaten := false")
+    L.append("\t\t\tfor _, o := range g {")
+    L.append("\t\t\t\t// §107.2: противоположный обычный кандидат сильнее")
+    L.append(f'\t\t\t\tif !o.defeater && o.positive != c.positive && {prio}[o.rule+">"+c.rule] {{')
+    L.append("\t\t\t\t\tbeaten = true")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t\t// §107.3: дефитер на ту же полярность, не преодолённый приоритетом")
+    L.append(f'\t\t\t\tif o.defeater && o.positive == c.positive && !{prio}[c.rule+">"+o.rule] {{')
+    L.append("\t\t\t\t\tbeaten = true")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t}")
+    L.append("\t\t\tif !beaten {")
+    L.append("\t\t\t\tout = append(out, c)")
+    L.append('\t\t\t\tsurvived[candKey(c.rule, c.urn, c.key, c.positive)] = true')
+    L.append("\t\t\t}")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("\tfor _, id := range ids {")
+    L.append("\t\tc := cands[id]")
+    L.append('\t\tapplied = append(applied, appliedCand{c.rule, c.defeater, c.urn, c.positive, c.key, !c.defeater && !survived[candKey(c.rule, c.urn, c.key, c.positive)]})')
+    L.append("\t}")
+    L.append("\treturn out")
+    L.append("}")
+    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'func rule_{r["name"]}() bool {{')
+        L.append("\tgrew := false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'\tif legalTime() < "{r["window"]["start"]}" {{\n\t\treturn false\n\t}}')
+            if r["window"].get("end"):
+                L.append(f'\tif legalTime() >= "{r["window"]["end"]}" {{\n\t\treturn false\n\t}}')
+        inner: list = []
+        levels, late_joins, late_filters = _early(r)
+        for (ai, aj, _at), (bi, bj, _bt) in late_joins:
+            inner.append(f'if !cmp(r{ai}[{aj}], "eq", r{bi}[{bj}]) {{@continue@}}')
+        for f in late_filters:
+            inner.append(f'if !eq(r{f["row"]}[{f["col"]}], {term(f["term"])}) {{@continue@}}')
+        for c in r["checks"]:
+            args = ", ".join(term(a) for a in c["args"])
+            predicate = json.dumps(c["pred"])
+            inner.append(f'if {_accepts(f"truthOf({predicate}, []Val{{{args}}})", c["accept"])} {{@continue@}}')
+        for g in r["guards"]:
+            inner.append(f'if !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":
+            inner.append(f'if addRow({json.dumps(r["head"]["pred"])}, []Val{{{args}}}, {"bitSP" if pos else "bitSN"}) {{@grew = true@}}')
+        else:
+            subst = ", ".join(term(a) for a in r["subst"])
+            inner.append(f'cand({json.dumps(r["name"])}, {str(r["strength"] == "defeater").lower()}, '
+                         f'{json.dumps(r["head"]["pred"])}, {str(pos).lower()}, []Val{{{args}}}, []Val{{{subst}}})')
+        early = {i: _go_checks(levels.get(i, [])) for i in range(len(r["atoms"]))}
+        body_text = "".join(inner) + "".join(x for v in early.values() for x in v)
+        ind = "\t"
+        depth = 0
+        if not r["atoms"]:
+            L.append(f"{ind}for once := 0; once < 1; once++ {{")
+            ind += "\t"
+            depth += 1
+        for i, a in enumerate(r["atoms"]):
+            p = json.dumps(a["pred"])
+            _go_wild_open(L, ind, i, a)
+            L.append(f'{ind}for i{i}, r{i} := range TABLES[{p}] {{')
+            ind += "\t"
+            depth += 1
+            if f"r{i}[" not in body_text:
+                L.append(f'{ind}_ = r{i}')
+            _block(L, ind, f'if {_accepts(f"maskStatus(SUP[{p}][RK[{p}][i{i}]])", a["accept"])} {{@continue@}}')
+            for line in early[i]:
+                _block(L, ind, line)
+            _go_wild(L, ind, i, a)
+        for line in inner:
+            if "@" in line:
+                _block(L, ind, line)
+            else:
+                L.append(ind + line)
+        for _ in range(depth):
+            ind = ind[:-1]
+            L.append(ind + "}")
+        L.append("\treturn grew")
+        L.append("}")
+        L.append("")
+    L.append("// Страты строгого слоя §110 (DECISION-0088): каждая — наименьшая неподвижная точка.")
+    L.append("var STRICT = [][]func() bool{" + ", ".join(
+        "{" + ", ".join(f"rule_{n}" for n in s) + "}" for s in plan["strata"]["strict"]) + "}")
+    waiting = _waiting_strata(L, plan, lambda name, strata: f"var {name} = [][]func() bool{{" + ", ".join(
+        "{" + ", ".join(f"rule_{n}" for n in s) + "}" for s in strata) + "}", "//")
+    L.append("")
+    L.append("func strictClosure(strata [][]func() bool) {")
+    L.append("\tfor _, stratum := range strata {")
+    L.append("\t\tfor grew := true; grew; {")
+    L.append("\t\t\tgrew = false")
+    L.append("\t\t\tfor _, rule := range stratum {")
+    L.append("\t\t\t\tif rule() {")
+    L.append("\t\t\t\t\tgrew = true")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t}")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("}")
+    L.append("")
+    _closures09(L, plan)
+    if v10:
+        raise ValueError("NORM_RANKS_UNAVAILABLE")
+    else:
+        L += NORM_STUBS
+    L.append("// Расписание фаз §111, решённое планом.")
+    L.append("func saturate() {")
+    if prep:
+        L.append("\tprepare()")
+    L.append("\tsurviving := []candidate{}")
+    for ph in plan["schedule"]:
+        kind = ph["phase"]
+        if kind not in PHASES:
+            raise ValueError(f"фаза расписания не поддержана эмиттером: {kind!r}")
+        if kind == "strict":
+            L.append(f"\tstrictClosure({waiting[tuple(ph['waiting'])] if ph.get('waiting') else 'STRICT'})")
+        elif kind == "closure":
+            if not ph.get("policies"):
+                L.append("\t// §70: фаза closure зарезервирована (DECISION-0237 F7), политик в срезе нет")
+            for name in ph.get("policies") or []:
+                L.append(f"\t{name}()")
+        elif kind == "candidates":
+            L.append(f'\t// страта {ph["stratum"]}: кандидаты §111 шаги 2–3')
+            L.append("\tcands = map[string]candidate{}")
+            for n in ph["rules"]:
+                L.append(f"\trule_{n}()")
+        elif kind == "defeat":
+            L.append("\tsurviving = defeat()")
+        elif kind == "norms":
+            L.append("\t// §135: позиции норм-правил после поражаемого слоя (DECISION-0242 K3)")
+            for n in plan.get("norms") or []:
+                L.append(f"\tnorm_{n['name']}()")
+        elif kind == "effects":
+            L.append("\tmaterializeEffects() // §127–§128")
+        elif kind == "surviving":
+            L.append("\tfor _, c := range surviving {")
+            L.append("\t\tbit := bitDN")
+            L.append("\t\tif c.positive {")
+            L.append("\t\t\tbit = bitDP")
+            L.append("\t\t}")
+            L.append("\t\taddRow(c.urn, c.row, bit)")
+            L.append("\t}")
+        else:
+            L.append(f'\t// страта {ph["stratum"]}: статус фиксирован, выводится при чтении (§111 шаг 7)')
+    L.append("\t_ = surviving")
+    L.append("}")
+    L.append("")
+    L.append("func register(urn string, row []Val) { addRow(urn, row, bitSP) }")
+    L.append("")
+    L.append("func registerNegative(urn string, row []Val) { addRow(urn, row, bitSN) }")
+    L.append("")
+    L.append("// KEY_CONFLICT §45.1/§196: считаются accepted-кортежи — strict/asserted positive-опоры.")
+    L.append("func keyConflicts() int {")
+    L.append("\tn := 0")
+    L.append("\tfor urn, keys := range KEYS {")
+    L.append("\t\tfor _, k := range keys {")
+    L.append("\t\t\tgroups := map[string]int{}")
+    L.append("\t\t\tfor i, row := range TABLES[urn] {")
+    L.append("\t\t\t\tif SUP[urn][RK[urn][i]]&bitSP == 0 {")
+    L.append("\t\t\t\t\tcontinue")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t\tproj := make([]Val, len(k))")
+    L.append("\t\t\t\tfor j, c := range k {")
+    L.append("\t\t\t\t\tproj[j] = row[c]")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t\tgroups[key(proj)]++")
+    L.append("\t\t\t}")
+    L.append("\t\t\tfor _, c := range groups {")
+    L.append("\t\t\t\tif c > 1 {")
+    L.append("\t\t\t\t\tn++")
+    L.append("\t\t\t\t}")
+    L.append("\t\t\t}")
+    L.append("\t\t}")
+    L.append("\t}")
+    L.append("\treturn n")
+    L.append("}")
+    L.append("func keyConflictPredicates() map[string]bool {")
+    L.append("\tout := map[string]bool{}")
+    L.append("\tfor urn, keys := range KEYS { rows := [][]Val{}; for i, row := range TABLES[urn] { if SUP[urn][RK[urn][i]]&bitSP != 0 { rows = append(rows, row) } }; for _, k := range keys { groups := map[string]int{}; for _, row := range rows { proj := make([]Val, len(k)); for i, c := range k { proj[i] = row[c] }; groups[key(proj)]++ }; for _, count := range groups { if count > 1 { out[urn] = true } } } }")
+    L.append("\treturn out")
+    L.append("}")
+    L.append("")
+    L.append("// Собственные факты пакета; reset возвращает модель к ним (чистое Evaluate API).")
+    L.append("func packageFacts() {")
+    for f in plan["facts"]:
+        bit = "bitSP" if f.get("polarity", "positive") == "positive" else "bitSN"
+        L.append(f'\taddRow({json.dumps(f["pred"])}, []Val{{' + ", ".join(term(a) for a in f["args"]) + f"}}, {bit})")
+    L.append("}")
+    L.append("")
+    L.append("func reset() {")
+    L.append("\tfor urn := range TABLES {")
+    L.append("\t\tTABLES[urn] = TABLES[urn][:0]")
+    L.append("\t\tRK[urn] = RK[urn][:0]")
+    L.append("\t\tSUP[urn] = map[string]int{}")
+    L.append("\t}")
+    L.append("\tcands = map[string]candidate{}")
+    L.append("\tapplied = nil")
+    if v09:
+        L.append("\tRULE_ISSUES = []string{}")
+        L.append("\tissueSeen = map[string]bool{}")
+        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("\tkindSeen = map[string]bool{}")
+    if v10:
+        L.append("\tpositions = nil")
+        L.append("\tblocked = map[string]bool{}")
+        L.append("\tblockedImm = map[string]bool{}")
+        L.append("\tnormIssueList = nil")
+        L.append("\tnormSeen = map[string]bool{}")
+        L.append("\tnormSeq = map[string]int{}")
+    L.append("\tpackageFacts()")
+    L.append("}")
+    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_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 _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 go_name(name: str) -> str:
+    """Основа имени Go в PascalCase: только буквы Unicode и десятичные цифры —
+    идентификатор Go не принимает комбинирующие знаки и прочие цифры."""
+    import unicodedata
+    base = "".join(w[:1].upper() + w[1:] for w in _api_words(name))
+    return "".join(c for c in base if unicodedata.category(c)[0] == "L" or unicodedata.category(c) == "Nd") or "X"
+
+
+def api_names(entries: list) -> dict:
+    """Нейтральное имя плана → основа имени функции Go (`Fact`/`Ask`/`Rows`
+    + основа). Совпадения после преобразования разводятся суффиксом `2`, `3`
+    в порядке плана (отсортирован по StableId), поэтому имена детерминированы."""
+    out, used = {}, set()
+    for e in entries:
+        base = go_name(e["name"])
+        name, n = base, 1
+        while name in used:
+            n += 1
+            name = f"{base}{n}"
+        used.add(name)
+        out[e["name"]] = name
+    return out
+
+
+def emit_api(plan: dict) -> str:
+    """API порождённого модуля (DECISION-0234, DECISION-0423): конструкторы
+    фактов по входам, функции вопросов и реестры по имени поверх `apiBase.go`,
+    общего с единым входом `evaluate`; ответ — `Answer` одной формы у L0 и L1,
+    отказ и ошибка формы — значения `error`. Глобального состояния и мьютекса
+    нет. Над каждой функцией — метки отношения и якоря `@source`."""
+    check_plan(plan)
+    api = _api(plan)
+    negation = "negation" in (plan.get("capabilities") or ())
+    L = ["package main", "",
+         "// Поверхность API порождённого модуля (DECISION-0234, DECISION-0423).",
+         "//",
+         "// Факты строятся функциями Fact* (и Negated* у модели L1) из литерал-термов §53 —",
+         "// конструкторов IntegerOf, DecimalOf, MoneyOf, TextOf, DateOf, EntityOf и других — либо из",
+         "// значений языка, однозначных по объявленному типу параметра. Вопрос Ask* —",
+         "// чистая функция: каждый вызов строит своё состояние модели и возвращает Answer",
+         "// либо ошибку (*InputError, *RefusedError). Вызовы из горутин независимы.", ""]
+    def meta(entry):
+        return (f'{json.dumps(entry["pred"])}, []string{{{", ".join(json.dumps(t) for t in entry["params"])}}}, '
+                f'[]string{{{", ".join(json.dumps(k) for k in entry["kinds"])}}}')
+    inp, qs = api_names(api["inputs"]), api_names(api["questions"])
+    for i in api["inputs"]:
+        n = len(i["params"])
+        params = ", ".join(f"a{j}" for j in range(n)) + (" interface{}" if n else "")
+        call = ", ".join(f"a{j}" for j in range(n))
+        for d in api_doc(i):
+            L.append("// " + d)
+        L.append(f"func Fact{inp[i['name']]}({params}) Fact {{")
+        L.append(f'\treturn makeFact({meta(i)}, []interface{{}}{{{call}}}, "Fact{inp[i["name"]]}", false)')
+        L.append("}")
+        L.append("")
+        if negation:
+            L.append("// Отрицательный факт §113 того же входа.")
+            L.append(f"func Negated{inp[i['name']]}({params}) Fact {{")
+            L.append(f'\treturn makeFact({meta(i)}, []interface{{}}{{{call}}}, "Negated{inp[i["name"]]}", true)')
+            L.append("}")
+            L.append("")
+    for q in api["questions"]:
+        n = len(q["params"])
+        params = "".join(f", a{j}" for j in range(n)) + (" interface{}" if n else "")
+        call = ", ".join(f"a{j}" for j in range(n))
+        for d in api_doc(q):
+            L.append("// " + d)
+        L.append(f"func Ask{qs[q['name']]}(facts []Fact, on string{params}) (Answer, error) {{")
+        L.append(f'\treturn askAPI({meta(q)}, facts, on, []interface{{}}{{{call}}}, {json.dumps(q["name"])}, CallOptions{{}})')
+        L.append("}")
+        L.append("")
+        L.append(f"// Установленные строки {q['name']} литерал-термами §53.")
+        L.append(f"func Rows{qs[q['name']]}(facts []Fact, on string) (Answer, error) {{")
+        L.append(f'\treturn rowsAPI({json.dumps(q["pred"])}, facts, on, {json.dumps(q["name"])}, CallOptions{{}})')
+        L.append("}")
+        L.append("")
+    L.append("// Реестры по имени — для обвязки и проверки: вопрос и вход по строке.")
+    L.append("var Questions = map[string]func(facts []Fact, on string, args []interface{}, opts CallOptions) (Answer, error){")
+    for q in api["questions"]:
+        L.append(f'\t{json.dumps(q["name"])}: func(facts []Fact, on string, args []interface{{}}, opts CallOptions) (Answer, error) {{')
+        L.append(f'\t\treturn askAPI({meta(q)}, facts, on, args, {json.dumps(q["name"])}, opts)')
+        L.append("\t},")
+    L.append("}")
+    L.append("")
+    L.append("var Inputs = map[string]func(args ...interface{}) Fact{")
+    for i in api["inputs"]:
+        L.append(f'\t{json.dumps(i["name"])}: func(args ...interface{{}}) Fact {{ return makeFact({meta(i)}, args, "Inputs[{i["name"]}]", false) }},')
+    L.append("}")
+    L.append("")
+    L.append("var Negated = map[string]func(args ...interface{}) Fact{")
+    if negation:
+        for i in api["inputs"]:
+            L.append(f'\t{json.dumps(i["name"])}: func(args ...interface{{}}) Fact {{ return makeFact({meta(i)}, args, "Negated[{i["name"]}]", true) }},')
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+# --- дескриптор цели ---------------------------------------------------------
+import shutil as _shutil
+from pathlib import Path as _Path
+
+HERE = _Path(__file__).resolve().parent
+EXT = "go"
+MODEL = "model.go"
+# Минимальная версия Go (строка `go` в go.mod, DECISION-0423 §2.7) — версия
+# проверок CI (`.github/workflows/candidate.yml`), а не машины генератора.
+TOOLCHAIN_MIN = "1.25"
+API = "api.go"
+# Виды вопросов, которые исполняет раннер цели; ворота исполняют вектор
+# только когда его вид поддержан ВСЕМИ активными целями.
+QUERY_KINDS = {"truth", "term", "collect"}
+
+
+def available():
+    import shutil as _sh
+    go = _sh.which("go")
+    return (True, go) if go else (False, "нет go в PATH")
+
+MAINS = {"runner": "runner.go", "cert": "cert.go", "apicheck": "apicheck.go"}
+
+
+def layout(proj, main: str) -> list:
+    proj = _Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    names = ("runtime.go", MAINS[main]) if main == "cert" else ("runtime.go", "evaluate.go", "apiBase.go", MAINS[main])
+    for name in names:
+        _shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    (proj / "go.mod").write_text(f"module lawgen\n\ngo {TOOLCHAIN_MIN}\n", encoding="utf-8")
+    out.append(proj / "go.mod")
+    return out
+
+
+def build(proj):
+    return ["go", "build", "-o", "app", "."], str(proj)
+
+
+def build_api(proj):
+    """Харнесс API — второй бинарь того же каталога под тегом `apicheck`."""
+    return ["go", "build", "-tags", "apicheck", "-o", "apicheck", "."], str(proj)
+
+
+def run(proj, main: str):
+    if main == "apicheck":
+        return [str(_Path(proj) / "apicheck")], None
+    return [str(_Path(proj) / "app")], None
+
+
+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")