arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/xlsx/README.ru.md

@@ -0,0 +1,176 @@
+# Excel как самостоятельный backend
+
+`./law dev backend … --target xlsx` компилирует модель в обычную `.xlsx`-книгу.
+После сборки **Excel сам пересчитывает формулы** при изменении входных ячеек.
+Arxo, Python, сервер, сеть, надстройки и макросы для использования книги не нужны.
+Для генерации достаточно стандартной библиотеки Python; новые зависимости
+в Rust, wasm и npm не добавляются.
+
+## Быстрый пример
+
+Из корня репозитория:
+
+```sh
+./law dev backend engines/backends/examples/xlsx/pricing.lawir.json \
+  --target xlsx \
+  --xlsx-config engines/backends/examples/xlsx/pricing.xlsx.json \
+  --out /tmp/arxo-excel-example
+```
+
+Откройте `/tmp/arxo-excel-example/xlsx/model.xlsx`. На листе `Inputs`:
+
+- `B4` — дата расчёта;
+- `A9` — включение первой строки: `1` / `0`;
+- `C9` — идентификатор полиса;
+- `D9` — категория `A` или `B`;
+- `E9` — базовая сумма.
+
+Начальный результат: `100.05 × 1.10`, округление `HALF_UP` до двух знаков →
+`110.06`. Замена суммы на `200` даёт `220`; замена категории на `B` при
+исходной сумме — `125.06`. Формулы книги остаются теми же.
+
+Пример **синтетический**, проверяет механизм генерации и не является тарифом
+ОГПО ВТС. Два правила намеренно выводят один результат: книга устраняет дубликат.
+
+## Состав поставки
+
+| Файл | Назначение |
+|---|---|
+| `model.xlsx` | Самостоятельный калькулятор |
+| `cells.json` | Адреса входов и выходов, эффективная конфигурация и лимиты |
+| `plan.json` | Общий план Arxo, из которого построена книга |
+| `law-backend.json` | Профиль, семантический хэш CLIR и SHA-256 файлов |
+| `README.txt` | Краткая инструкция пользователю книги |
+
+Листы: `Results` — строки отношений, `Inputs` — редактируемые данные,
+`Calculation` — вычисление и проверка промежуточных значений, `Model` —
+паспорт и ограничения. Якоря источников из API плана, если они есть, находятся
+на `Model`; строка результата содержит идентификатор правила.
+
+## Конфигурация входов
+
+`--xlsx-config` принимает JSON-объект:
+
+```json
+{
+  "profile": "excel-calculator/0.1",
+  "currency": "KZT",
+  "legalTime": "2026-09-15",
+  "tables": {
+    "urn:law:example:excel#quote": {
+      "rows": 2,
+      "scales": [0, 0, 2],
+      "columns": ["Полис", "Категория", "Базовая сумма, KZT"],
+      "label": "Данные расчёта",
+      "values": [["POLICY-1", "A", "100.05"]]
+    }
+  }
+}
+```
+
+Имена таблиц — точные `pred` из общего плана. Для каждой таблицы:
+
+- `rows` задаёт **число входных слотов**, от 0 до 100; начальные строки `values`
+  включены, остальные выключены. При `rows: 0` отношение получает только
+  собственные факты пакета и результаты правил.
+- По умолчанию предикат без правил-производителей и собственных фактов получает
+  один выключенный входной слот; остальные — ноль. Можно явно добавить входы
+  производному отношению. Служебное `always` входом быть не может.
+- `scales` задаёт число десятичных знаков для **каждой** колонки: по умолчанию
+  Decimal — 4, Money — 2, Integer/Text/Date — 0. Допустимы 0..6; ненулевой
+  масштаб разрешён только Decimal и Money. Точность выходных колонок тоже
+  задаётся здесь: генератор не округляет до неё без явного `round` модели.
+- `columns` и `label` необязательны. Количество значений/меток/масштабов должно
+  совпадать с арностью. Дата задаётся ISO-строкой, в книге хранится числом.
+- `currency` обязательна для Money. Вся книга работает в одной явно выбранной
+  валюте; литерал другой валюты отвергает сборку.
+
+Конфигурация необязательна для модели без Money. Если `legalTime` не указана,
+дата остаётся пустой и пользователь должен заполнить её. Дата всегда явная:
+генератор не подставляет `TODAY()` и не зависит от времени запуска.
+
+Пустая включённая строка — ошибочный ввод. Отсутствующий факт представляется
+выключенной строкой. Пустой Text во входе вне профиля; строка `"0"` не является
+числом, числовой ноль допустим. Проверки формулами продолжают действовать,
+если вставка через буфер обошла Excel Data Validation.
+
+## Поддерживаемый профиль
+
+`excel-calculator/0.1` принимает общий план `law-backend-plan/0.7`:
+
+- строгие положительные правила с ациклическими зависимостями предикатов;
+- собственные факты, несколько входных строк, соединения, фильтры и сравнения;
+- Text, Integer, Decimal, Money и Date; Text сравнивается с учётом регистра;
+- `add`, `sub`, `mul`, точное ограниченное `div`, евклидов `mod`, `min`, `max`,
+  `abs`, явный `round(…, <литерал 0..6>, "HALF_UP")`;
+- окна правил и редакций, уже пониженные в `[start, end)` по `legal_time`;
+- множество кортежей: повтор одного вывода удаляется; разные значения одного
+  ключа сохраняются и отмечаются `KEY_CONFLICT`.
+
+Рекурсия, отрицательные/поражаемые правила, приоритеты, агрегаты, замыкания,
+нормативные позиции, `pow`, календарные функции, пользовательские типы,
+перечисления, Boolean, Rational, Instant и Quantity вне этого профиля.
+Неподдерживаемая форма отвергается **даже в правиле с пустым входом**.
+Общий план и другие backend от этого не меняют семантику.
+
+Формулы разворачивают декартовы произведения ограниченных входных слотов.
+Максимум — 2000 строк-кандидатов, 100000 ячеек, 10 аргументов отношения,
+8000 UTF-16 единиц формулы. Увеличить число входных строк можно пересборкой,
+добавление строки вручную под таблицей не расширяет программу.
+
+### Числа и статусы
+
+Внутри книги `100.05` при масштабе 2 представлен коэффициентом `10005`.
+Арифметика и сравнения работают над целыми коэффициентами в диапазоне
+`±10^12`; масштаб промежуточного значения — 0..12. Это намеренно более
+узкая область, чем все значения Arxo: переполнение **промежуточного**
+коэффициента тоже требует отказа, даже если итог мог бы поместиться.
+
+Деление разрешено, когда целочисленный числитель укладывается в предел и
+частное точно представимо при масштабе `max(6, scale(lhs)-scale(rhs))`.
+`1 / 3`, деление на ноль и потеря разрядов при записи результата не превращаются
+в приближённое число. Округление `HALF_UP` определяется целым остатком,
+включая отрицательные значения на половине шага.
+
+| Статус | Значение |
+|---|---|
+| `READY` | Вход и вычисление укладываются в профиль |
+| `INVALID_INPUT` | Пустой/неверный аргумент включённой строки, дата или переключатель |
+| `CALCULATION_REFUSED` | Промежуточная арифметика/масштаб вне профиля либо деление на ноль; в Calculation видна ошибка |
+| `PRESENT` | Данный кортеж выведен |
+| `NEITHER` | Для слота нет вывода; это не доказательство отрицания |
+| `KEY_CONFLICT` | Несколько разных выведенных кортежей с одним ключом |
+
+При отказе значения на Results недоступны; частичный ответ не выдаётся.
+Статусы книги относятся к этому профилю, не подменяют канонический документ
+evaluation. Proof graph в книгу не компилируется.
+
+Даты ограничены `1900-03-01..9999-12-31`, система Excel 1900. Это исключает
+несуществующий день 29 февраля 1900 года. Книга задаёт автоматический полный
+пересчёт без итераций и не записывает выдуманные кэшированные результаты.
+
+## Проверка
+
+```sh
+.venv-work-profile/bin/python verify/ci/gates/backends/check_xlsx.py --recalculate
+```
+
+`--soffice <путь>` выбирает LibreOffice; `--keep <новый каталог>` сохраняет
+книги и результаты. Без `--recalculate` выполняются только структурные пробы,
+а отсутствие проверки пересчёта явно сообщается. С флагом отсутствие/падение
+LibreOffice считается ошибкой. Он запускается с отдельным временным профилем.
+
+Тест изменяет ячейки **однажды сгенерированной** книги и проверяет реальные
+кэши после пересчёта. Полные множества допустимых результатов сверяются с
+оракулом Arxo; отдельно проверяются отсутствие вывода, ошибки, границы,
+конфликт ключа, безопасность текстовых ячеек, детерминированные байты и
+сохранение существующей поставки при отказе. Python-поставка проверяется
+через прежний путь записи текстового backend.
+
+Проверено в LibreOffice 26.2.3.2. Microsoft Excel на машине проверки отсутствует;
+его собственный пересчёт пока не проверялся. Импорт, пересчёт и визуальный
+просмотр примера дополнительно выполнены через Artifact Tool. Полный корпус
+и общие ворота не запускались; замороженные пакеты не проверялись.
+
+Основание ограничений: [точность Excel и IEEE 754](https://learn.microsoft.com/en-us/troubleshoot/microsoft-365-apps/excel/floating-point-arithmetic-inaccurate-result),
+[лимиты Excel](https://support.microsoft.com/en-us/excel/excel-specifications-and-limits).

arxo_codegen/targets/xlsx/emit.py

@@ -0,0 +1,198 @@
+"""XLSX delivery descriptor and deterministic SpreadsheetML serializer.
+
+No Office/Node dependency is required to generate or use the workbook.
+All execution-profile decisions and formulas live in excel_plan.py.
+"""
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from xml.etree import ElementTree as ET
+
+import excel_plan as X
+
+MODEL = "model.xlsx"
+PROFILE = X.PROFILE
+PROTOCOL = "workbook"
+CAPABILITIES = set()
+QUERY_KINDS = set()
+NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+PKG = "http://schemas.openxmlformats.org/package/2006/relationships"
+CONTENT = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+
+def available():
+    return True, "XLSX: стандартная библиотека Python; пересчёт — Excel/LibreOffice"
+
+
+def xml(element):
+    return ET.tostring(element, encoding="utf-8", xml_declaration=True)
+
+
+def styles():
+    root = ET.Element("styleSheet", xmlns=NS)
+    fmts = ET.SubElement(root, "numFmts", count="8")
+    formats = ["#,##0"] + ["#,##0." + "0" * n for n in range(1, 7)] + ["yyyy-mm-dd"]
+    for i, fmt in enumerate(formats, 164):
+        ET.SubElement(fmts, "numFmt", numFmtId=str(i), formatCode=fmt)
+    fonts = ET.SubElement(root, "fonts", count="3")
+    for size, bold, color in ((10, False, "FF202124"), (14, True, "FF202124"), (10, True, "FFFFFFFF")):
+        font = ET.SubElement(fonts, "font")
+        ET.SubElement(font, "sz", val=str(size))
+        ET.SubElement(font, "name", val="Arial")
+        ET.SubElement(font, "color", rgb=color)
+        if bold:
+            ET.SubElement(font, "b")
+    fills = ET.SubElement(root, "fills", count="4")
+    for pattern, color in (("none", None), ("gray125", None), ("solid", "FF304860"), ("solid", "FFFFF2CC")):
+        p = ET.SubElement(ET.SubElement(fills, "fill"), "patternFill", patternType=pattern)
+        if color:
+            ET.SubElement(p, "fgColor", rgb=color)
+            ET.SubElement(p, "bgColor", indexed="64")
+    borders = ET.SubElement(root, "borders", count="1")
+    border = ET.SubElement(borders, "border")
+    for side in ("left", "right", "top", "bottom", "diagonal"):
+        ET.SubElement(border, side)
+    base = ET.SubElement(root, "cellStyleXfs", count="1")
+    ET.SubElement(base, "xf", numFmtId="0", fontId="0", fillId="0", borderId="0")
+    xfs = ET.SubElement(root, "cellXfs")
+    ids = {}
+
+    def add(name, font=0, fill=0, num=0, wrap=False):
+        ids[name] = len(ids)
+        xf = ET.SubElement(xfs, "xf", numFmtId=str(num), fontId=str(font), fillId=str(fill), borderId="0",
+                           xfId="0", applyAlignment="1", applyNumberFormat="1")
+        alignment = {"vertical": "center"}
+        if wrap:
+            alignment["wrapText"] = "1"
+        if name == "header":
+            alignment["horizontal"] = "center"
+        ET.SubElement(xf, "alignment", **alignment)
+
+    add("body")
+    add("title", font=1)
+    add("header", font=2, fill=2, wrap=True)
+    add("inputtext", fill=3)
+    for i in range(7):
+        add(f"num{i}", num=164 + i)
+        add(f"input{i}", fill=3, num=164 + i)
+    add("date", num=171)
+    add("inputdate", fill=3, num=171)
+    xfs.set("count", str(len(ids)))
+    cs = ET.SubElement(root, "cellStyles", count="1")
+    ET.SubElement(cs, "cellStyle", name="Normal", xfId="0", builtinId="0")
+    dxf = ET.SubElement(ET.SubElement(root, "dxfs", count="1"), "dxf")
+    font = ET.SubElement(dxf, "font")
+    ET.SubElement(font, "b")
+    ET.SubElement(font, "color", rgb="FF9C0006")
+    fill = ET.SubElement(ET.SubElement(dxf, "fill"), "patternFill", patternType="solid")
+    ET.SubElement(fill, "fgColor", rgb="FFFFC7CE")
+    ET.SubElement(fill, "bgColor", rgb="FFFFC7CE")
+    return xml(root), ids
+
+
+def sheet_xml(sheet, style_ids):
+    root = ET.Element("worksheet", xmlns=NS)
+    view = ET.SubElement(ET.SubElement(root, "sheetViews"), "sheetView", workbookViewId="0", showGridLines="0")
+    if sheet["name"] == "Calculation":
+        ET.SubElement(view, "pane", ySplit="6", topLeftCell="A7", activePane="bottomLeft", state="frozen")
+    ET.SubElement(root, "sheetFormatPr", defaultRowHeight="22")
+    cols = ET.SubElement(root, "cols")
+    widths = {"Results": [24] + [24] * 10 + [36, 60], "Inputs": [28, 14] + [24] * 10 + [3, 24],
+              "Calculation": [64, 26, 26, 14], "Model": [29, 115]}[sheet["name"]]
+    for i, width in enumerate(widths, 1):
+        ET.SubElement(cols, "col", min=str(i), max=str(i), width=str(width), customWidth="1")
+    rows = {}
+    for cell in sheet["cells"]:
+        n = int(''.join(c for c in cell["cell"] if c.isdigit()))
+        rows.setdefault(n, []).append(cell)
+    data = ET.SubElement(root, "sheetData")
+    for n, cells in sorted(rows.items()):
+        row = ET.SubElement(data, "row", r=str(n), ht="32" if any(c["style"] == "header" for c in cells) else "24", customHeight="1")
+        def index(c):
+            out = 0
+            for x in c["cell"]:
+                if x.isalpha():
+                    out = out * 26 + ord(x) - 64
+            return out
+        for cell in sorted(cells, key=index):
+            value, formula = cell["value"], cell["formula"]
+            c = ET.SubElement(row, "c", r=cell["cell"], s=str(style_ids[cell["style"]]))
+            if formula is not None:
+                ET.SubElement(c, "f").text = formula
+                # No invented cached value: the consuming engine recalculates.
+            elif isinstance(value, bool):
+                c.set("t", "b")
+                ET.SubElement(c, "v").text = "1" if value else "0"
+            elif isinstance(value, (int, float)):
+                ET.SubElement(c, "v").text = str(value)
+            elif value is not None:
+                c.set("t", "inlineStr")
+                text = ET.SubElement(ET.SubElement(c, "is"), "t")
+                text.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+                text.text = str(value)
+    for i, spec in enumerate(sheet.get("warnings", []), 1):
+        cf = ET.SubElement(root, "conditionalFormatting", sqref=spec["sqref"])
+        rule = ET.SubElement(cf, "cfRule", type="expression", dxfId="0", priority=str(i))
+        ET.SubElement(rule, "formula").text = spec["formula"]
+    if sheet["validations"]:
+        dvs = ET.SubElement(root, "dataValidations", count=str(len(sheet["validations"])))
+        for spec in sheet["validations"]:
+            dv = ET.SubElement(dvs, "dataValidation", type="custom", sqref=spec["sqref"],
+                               allowBlank="1", showErrorMessage="1", errorTitle="Неверный ввод",
+                               error="Значение вне допустимого диапазона", errorStyle="stop")
+            ET.SubElement(dv, "formula1").text = spec["formula"]
+    ET.SubElement(root, "pageMargins", left="0.3", right="0.3", top="0.4", bottom="0.4", header="0.2", footer="0.2")
+    return xml(root)
+
+
+def serialize(plan):
+    if plan.get("format") != X.FORMAT:
+        raise ValueError("неизвестная версия Excel-плана")
+    style_data, style_ids = styles()
+    workbook = ET.Element("workbook", xmlns=NS, **{"xmlns:r": REL})
+    ET.SubElement(workbook, "workbookPr", date1904="0")
+    ET.SubElement(ET.SubElement(workbook, "bookViews"), "workbookView", activeTab="0")
+    sheets = ET.SubElement(workbook, "sheets")
+    relationships = ET.Element("Relationships", xmlns=PKG)
+    types = ET.Element("Types", xmlns=CONTENT)
+    ET.SubElement(types, "Default", Extension="rels", ContentType="application/vnd.openxmlformats-package.relationships+xml")
+    ET.SubElement(types, "Default", Extension="xml", ContentType="application/xml")
+    entries = {"xl/styles.xml": style_data}
+    for i, sheet in enumerate(plan["sheets"], 1):
+        ET.SubElement(sheets, "sheet", name=sheet["name"], sheetId=str(i), **{"r:id": f"rId{i}"})
+        ET.SubElement(relationships, "Relationship", Id=f"rId{i}", Type=REL + "/worksheet", Target=f"worksheets/sheet{i}.xml")
+        ET.SubElement(types, "Override", PartName=f"/xl/worksheets/sheet{i}.xml", ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml")
+        entries[f"xl/worksheets/sheet{i}.xml"] = sheet_xml(sheet, style_ids)
+    ET.SubElement(workbook, "calcPr", calcId="0", calcMode="auto", fullCalcOnLoad="1", forceFullCalc="1", iterate="0")
+    ET.SubElement(relationships, "Relationship", Id="styles", Type=REL + "/styles", Target="styles.xml")
+    for name, kind in (("workbook", "sheet.main"), ("styles", "styles")):
+        ET.SubElement(types, "Override", PartName=f"/xl/{name}.xml", ContentType=f"application/vnd.openxmlformats-officedocument.spreadsheetml.{kind}+xml")
+    root_rels = ET.Element("Relationships", xmlns=PKG)
+    ET.SubElement(root_rels, "Relationship", Id="rId1", Type=REL + "/officeDocument", Target="xl/workbook.xml")
+    entries.update({"[Content_Types].xml": xml(types), "_rels/.rels": xml(root_rels),
+                    "xl/workbook.xml": xml(workbook), "xl/_rels/workbook.xml.rels": xml(relationships)})
+    out = io.BytesIO()
+    with zipfile.ZipFile(out, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for name, data in sorted(entries.items()):
+            info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0))
+            info.compress_type = zipfile.ZIP_DEFLATED
+            archive.writestr(info, data)
+    return out.getvalue()
+
+
+def emit(plan, config=None):
+    return serialize(X.build(plan, config))
+
+
+def artifacts(plan, config=None):
+    prepared = X.build(plan, config)
+    return {MODEL: serialize(prepared),
+            "cells.json": (json.dumps(prepared["mapping"], ensure_ascii=False, indent=2) + "\n").encode(),
+            "README.txt": ("Откройте model.xlsx в Excel. Меняйте жёлтые ячейки листа Inputs.\n"
+                           "Дата расчёта обязательна; переключатель 1 включает строку, 0 выключает.\n"
+                           "Результаты пересчитываются формулами без Arxo, сети и макросов.\n"
+                           "Границы профиля — на листе Model. Для изменения числа входных строк пересоберите книгу.\n"
+                           "cells.json описывает расположение ячеек и параметры сборки.\n").encode()}

arxo_codegen/temporal.py

@@ -0,0 +1,59 @@
+"""Current §82.2 admission. Only typed temporal fields are visited."""
+import datetime
+import re
+
+DATE = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}\Z")
+INSTANT = re.compile(r"([0-9]{4}-[0-9]{2}-[0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?(Z|[+-][0-9]{2}:[0-9]{2})\Z")
+
+
+def date_valid(value):
+    if not isinstance(value, str) or not DATE.fullmatch(value):
+        return False
+    try:
+        datetime.date.fromisoformat(value)
+        return True
+    except ValueError:
+        return False
+
+
+def instant_valid(value):
+    m = INSTANT.fullmatch(value) if isinstance(value, str) else None
+    return bool(m and date_valid(m[1]) and int(m[2]) < 24 and int(m[3]) < 60
+                and int(m[4]) < 60 and (m[6] == "Z" or
+                    (int(m[6][1:3]) < 24 and int(m[6][4:6]) < 60)))
+
+
+def validate_ir(ir, refuse):
+    def bound(value, side, pointer):
+        if side in ("start", "end") and value == ("-infinity" if side == "start" else "infinity"):
+            return
+        if not (date_valid(value) or instant_valid(value)):
+            raise refuse(f"TEMPORAL_BOUND_INVALID: ir:{pointer}")
+
+    def interval(value, pointer):
+        if not isinstance(value, dict):
+            raise refuse(f"TEMPORAL_BOUND_INVALID: ir:{pointer}")
+        for side in ("start", "end"):
+            if side in value:
+                bound(value[side], side, pointer + "/" + side)
+
+    fields = {"assertion": "valid", "calendar_snapshot": "valid", "evidence_item": "valid",
+              "support_edge": "valid", "closure_policy": "effective", "constraint": "effective",
+              "interpretation": "effective", "rule": "effective", "entrenchment": "window"}
+    for i, node in enumerate(ir.get("nodes") or []):
+        kind = node.get("kind")
+        prefix = f"/nodes/{i}"
+        field = fields.get(kind)
+        if field and field in node:
+            interval(node[field], prefix + "/" + field)
+        if kind == "rule":
+            for j, value in enumerate(node.get("governs") or []):
+                interval(value, f"{prefix}/governs/{j}")
+        if kind == "source_edition":
+            for j, event in enumerate(node.get("lifecycle") or []):
+                if "extent" in event:
+                    value, pointer = event["extent"], f"{prefix}/lifecycle/{j}/extent"
+                    if isinstance(value, dict):
+                        interval(value, pointer)
+                    else:
+                        bound(value, None, pointer)

arxo_codegen/test_alias_types.py

@@ -0,0 +1,171 @@
+"""Алиасы типов §40 и сущности `law.std.actors` §261 в срезе (W2, часть 1).
+
+Оракул сверяет типы §189 за цепочкой алиасов (`facts._unalias`, E-0097/E-0098);
+план обязан читать те же цепочки: алиас на std-тип, на сущность (в том числе
+чужого пакета мира и цепочкой), на перечисление — прозрачны; цель без пакета
+в мире остаётся отказом с именем цели. Std-акторы — идентичности."""
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import plan as P  # noqa: E402
+
+NS = "urn:law:test:alias"
+WNS = "urn:law:test:alias-world"
+TEXT, NATURAL, INT = "urn:law:std#Text", "urn:law:std#Natural", "urn:law:std#Integer"
+ACTOR = "urn:law:std#Actor"
+H = "sha256:" + "0" * 64
+
+
+def _rel(ns: str, name: str, kind: str, params: list[tuple[str, str]]) -> dict:
+    return {"kind": "symbol_decl", "symbolKind": "relation", "id": f"{ns}#{name}", "package": ns,
+            "name": name, "relationKind": kind, "contentHash": H,
+            "parameters": [{"id": f"{ns}#{name}/arg/{p}", "name": p, "type": {"name": t}} for p, t in params]}
+
+
+def _alias(ns: str, name: str, target: str) -> dict:
+    return {"kind": "type_decl", "typeKind": "alias", "id": f"{ns}#{name}", "package": ns,
+            "name": name, "target": {"name": target}, "contentHash": H}
+
+
+def _entity(ns: str, name: str) -> dict:
+    return {"kind": "type_decl", "typeKind": "entity", "id": f"{ns}#{name}", "package": ns,
+            "name": name, "contentHash": H}
+
+
+def _enum(ns: str, name: str, variants: list[str]) -> dict:
+    return {"kind": "type_decl", "typeKind": "enum", "id": f"{ns}#{name}", "package": ns,
+            "name": name, "variants": variants, "contentHash": H}
+
+
+def _lit(pred: str, args: list[dict]) -> dict:
+    return {"kind": "literal", "polarity": "positive", "predicate": pred, "args": args}
+
+
+def _var(i: int) -> dict:
+    return {"kind": "var", "var": f"v{i}"}
+
+
+def _rule(ns: str, name: str, variables: list[tuple[int, str]], body_items: list[dict], head: dict) -> dict:
+    body = body_items[0] if len(body_items) == 1 else {"kind": "and", "items": body_items}
+    return {"kind": "rule", "id": f"{ns}#{name}", "package": ns, "strength": "strict",
+            "variables": [{"id": f"v{i}", "type": {"name": t}} for i, t in variables],
+            "body": body, "head": head, "scope": {"kind": "boolean", "value": True},
+            "interpretations": [], "contentHash": H}
+
+
+def _established(lit: dict) -> dict:
+    return {"kind": "status", "status": "established", "formula": lit}
+
+
+def _ir(nodes: list[dict], ns: str = NS, name: str = "test.alias", imports: list[dict] | None = None) -> dict:
+    return {"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11",
+            "package": {"name": name, "version": "0.1.0", "namespace": ns, "semanticHash": H},
+            "imports": imports or [], "features": ["core-executable"], "nodes": nodes,
+            "strata": [], "metadata": {}}
+
+
+def _plan_types(plan: dict) -> dict:
+    return {r["id"]: r for r in plan.get("relations", [])} if isinstance(plan.get("relations"), list) else {}
+
+
+class AliasTests(unittest.TestCase):
+    def test_alias_of_std_type_is_transparent(self):
+        # ERR-E0098-ALIAS-VALUE-EVAL на 0.2: `type N = Natural; relation r(n: N)`, гард `n > 3`.
+        nodes = [_alias(NS, "N", NATURAL),
+                 _rel(NS, "r", "empirical", [("n", f"{NS}#N")]),
+                 _rel(NS, "big", "institutional", [("n", f"{NS}#N")]),
+                 _rule(NS, "Big", [(0, f"{NS}#N")],
+                       [{"kind": "comparison", "op": "gt", "left": _var(0),
+                         "right": {"kind": "value", "type": {"name": INT}, "value": 3}},
+                        _established(_lit(f"{NS}#r", [_var(0)]))],
+                       _lit(f"{NS}#big", [_var(0)]))]
+        planner = P.Builder(_ir(nodes))
+        planner._index()
+        self.assertEqual(planner._t(f"{NS}#N"), NATURAL)
+        self.assertEqual(planner.ts(f"{NS}#N"), "dec")
+        P.build_plan(_ir(nodes))
+
+    def test_alias_chain_to_entity_and_alias_to_enum(self):
+        nodes = [_entity(NS, "Person"), _alias(NS, "Party", f"test.alias#Person"),
+                 _alias(NS, "Claimant", f"test.alias#Party"),
+                 _enum(NS, "Color", ["Red", "Blue"]), _alias(NS, "Hue", f"test.alias#Color"),
+                 _rel(NS, "party", "empirical", [("p", f"{NS}#Party"), ("c", f"{NS}#Hue")]),
+                 _rel(NS, "claimant", "institutional", [("p", f"{NS}#Claimant")]),
+                 _rule(NS, "Claim", [(0, f"{NS}#Claimant")],
+                       [_established(_lit(f"{NS}#party", [_var(0), {"kind": "const_ref", "id": f"{NS}#Red"}]))],
+                       _lit(f"{NS}#claimant", [_var(0)]))]
+        planner = P.Builder(_ir(nodes))
+        planner._index()
+        self.assertEqual(planner._t(f"{NS}#Claimant"), f"{NS}#Person")
+        self.assertEqual(planner.ts(f"{NS}#Claimant"), "text")
+        self.assertEqual(planner.ts(f"{NS}#Hue"), "enum")
+        P.build_plan(_ir(nodes))
+        # Член чужого перечисления в слоте алиаса — тот же отказ §189, что у прямого имени.
+        bad = list(nodes)
+        bad[3] = _enum(NS, "Color", ["Red", "Blue"])
+        bad.append(_enum(NS, "Shape", ["Round"]))
+        bad[-2] = _rule(NS, "Claim", [(0, f"{NS}#Claimant")],
+                        [_established(_lit(f"{NS}#party", [_var(0), {"kind": "const_ref", "id": f"{NS}#Round"}]))],
+                        _lit(f"{NS}#claimant", [_var(0)]))
+        with self.assertRaisesRegex(P.Refused, "§189"):
+            P.build_plan(_ir(bad))
+
+    def test_alias_to_world_entity_and_unresolved_target(self):
+        world = _ir([_entity(WNS, "Thing")], ns=WNS, name="test.alias_world")
+        nodes = [_alias(NS, "Item", "test.alias_world#Thing"),
+                 _rel(NS, "owned", "empirical", [("i", f"{NS}#Item")]),
+                 _rel(NS, "listed", "institutional", [("i", f"{NS}#Item")]),
+                 _rule(NS, "List", [(0, f"{NS}#Item")],
+                       [_established(_lit(f"{NS}#owned", [_var(0)]))], _lit(f"{NS}#listed", [_var(0)]))]
+        ir = _ir(nodes, imports=[{"package": {"name": "test.alias_world", "version": "0.1.0"}}])
+        planner = P.Builder(ir, [world])
+        planner._index()
+        self.assertEqual(planner._t(f"{NS}#Item"), f"{WNS}#Thing")
+        P.build_plan(ir, world=[world])
+        # Без снимка пакета цели имя остаётся строкой и называется в отказе.
+        with self.assertRaisesRegex(P.Refused, "тип аргумента вне среза генератора: test.alias_world#Thing"):
+            P.build_plan(_ir(nodes))
+
+    def test_std_actor_is_an_entity(self):
+        nodes = [_rel(NS, "owns", "empirical", [("a", ACTOR), ("t", TEXT)]),
+                 _rel(NS, "holder", "institutional", [("a", ACTOR)]),
+                 _rule(NS, "Holder", [(0, ACTOR), (1, TEXT)],
+                       [_established(_lit(f"{NS}#owns", [_var(0), _var(1)]))], _lit(f"{NS}#holder", [_var(0)]))]
+        planner = P.Builder(_ir(nodes))
+        planner._index()
+        self.assertEqual(planner.ts(ACTOR), "text")
+        self.assertEqual(planner.ts("urn:law:std#Court"), "text")
+        P.build_plan(_ir(nodes))
+        # W2 часть 3: событие в слоте — идентичность (§79.1: `entity_ref` на снимок);
+        # конструктор-запись отвергает раннер, не план.
+        self.assertEqual(planner.ts("urn:law:std#Event"), "text")
+        P.build_plan(_ir([_rel(NS, "happened", "empirical", [("e", "urn:law:std#Event")]),
+                          _rel(NS, "noted", "institutional", [("e", "urn:law:std#Event")]),
+                          _rule(NS, "Note", [(0, "urn:law:std#Event")],
+                                [_established(_lit(f"{NS}#happened", [_var(0)]))],
+                                _lit(f"{NS}#noted", [_var(0)]))]))
+        # Релиз 0.1.5: LegalContext, LegalRole, Jurisdiction — идентичности.
+        for std in ("LegalContext", "LegalRole", "Jurisdiction"):
+            self.assertEqual(planner.ts(f"urn:law:std#{std}"), "text")
+        P.build_plan(_ir([_rel(NS, "within", "empirical", [("c", "urn:law:std#LegalContext"),
+                                                          ("j", "urn:law:std#Jurisdiction")]),
+                          _rel(NS, "known", "institutional", [("c", "urn:law:std#LegalContext")]),
+                          _rule(NS, "Known", [(0, "urn:law:std#LegalContext"), (1, "urn:law:std#Jurisdiction")],
+                                [_established(_lit(f"{NS}#within", [_var(0), _var(1)]))],
+                                _lit(f"{NS}#known", [_var(0)]))]))
+        # Сертифицированные границы — своё значение §259.2, вне среза.
+        with self.assertRaisesRegex(P.Refused, "тип аргумента вне среза генератора: urn:law:std#Bounds"):
+            P.build_plan(_ir([_rel(NS, "measured", "empirical", [("b", "urn:law:std#Bounds")]),
+                              _rel(NS, "fine", "institutional", [("b", "urn:law:std#Bounds")]),
+                              _rule(NS, "Fine", [(0, "urn:law:std#Bounds")],
+                                    [_established(_lit(f"{NS}#measured", [_var(0)]))],
+                                    _lit(f"{NS}#fine", [_var(0)]))]))
+
+
+if __name__ == "__main__":
+    unittest.main()