arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/bsl/cert.bsl

@@ -0,0 +1,113 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает, что
+// получилось. Ожидания сверяют ворота, харнесс их не читает.
+Перем РТ;
+Перем J;
+
+Функция Лит(Х)
+	Если ТипЗнч(Х) = Тип("Строка") Тогда
+		Возврат Х;
+	ИначеЕсли Х.Получить("dec") <> Неопределено Тогда
+		Возврат РТ.op_dec(Х.Получить("dec"));
+	ИначеЕсли Х.Получить("money") <> Неопределено Тогда
+		Возврат РТ.op_money(Х.Получить("money"), Х.Получить("cur"));
+	ИначеЕсли Х.Получить("text") <> Неопределено Тогда
+		Возврат Х.Получить("text");
+	ИначеЕсли Х.Получить("date") <> Неопределено Тогда
+		Возврат РТ.op_date(Х.Получить("date"));
+	ИначеЕсли Х.Получить("sym") <> Неопределено Тогда
+		Возврат РТ.op_sym(Х.Получить("sym"));
+	ИначеЕсли Х.Получить("row") <> Неопределено Тогда
+		Ряд = Новый Массив;
+		Для Каждого Эл Из Х.Получить("row") Цикл
+			Ряд.Добавить(Лит(Эл));
+		КонецЦикла;
+		Возврат Ряд;
+	КонецЕсли;
+	ВызватьИсключение "литерал фикстуры";
+КонецФункции
+
+// Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+Функция Цифры(Ц, Масштаб)
+	Тело = РТ.ЗаписьЦелого(Ц);
+	Отр = Лев(Тело, 1) = "-";
+	Если Отр Тогда
+		Тело = Сред(Тело, 2);
+	КонецЕсли;
+	Пока СтрДлина(Тело) < Масштаб + 1 Цикл
+		Тело = "0" + Тело;
+	КонецЦикла;
+	Если Масштаб > 0 Тогда
+		Тело = Лев(Тело, СтрДлина(Тело) - Масштаб) + "." + Прав(Тело, Масштаб);
+	КонецЕсли;
+	Возврат ?(Отр, "-", "") + Тело;
+КонецФункции
+
+Функция Отобразить(З)
+	В = РТ.ВидЗнач(З);
+	Если З = Неопределено Тогда
+		Возврат "null";
+	ИначеЕсли ТипЗнч(З) = Тип("Булево") Тогда
+		Возврат ?(З, "true", "false");
+	ИначеЕсли В = "text" Тогда
+		Возврат J.ТекстJSON(З);
+	ИначеЕсли В = "money" Тогда
+		Возврат J.ТекстJSON(Цифры(З.Ц, З.Масштаб) + " " + З.Вал);
+	ИначеЕсли В = "date" Тогда
+		Возврат J.ТекстJSON(З.Зн);
+	ИначеЕсли В = "sym" Тогда
+		Возврат J.ТекстJSON(З.Ид);
+	КонецЕсли;
+	Возврат J.ТекстJSON(Цифры(З.Ц, З.Масштаб));
+КонецФункции
+
+Функция Исполнить(Случай)
+	А = Новый Массив;
+	Для Каждого Х Из Случай.Получить("args") Цикл
+		А.Добавить(Лит(Х));
+	КонецЦикла;
+	Оп = Случай.Получить("op");
+	Если Оп = "dec" Тогда Возврат РТ.op_dec(А[0]);
+	ИначеЕсли Оп = "money" Тогда Возврат РТ.op_money(А[0], А[1]);
+	ИначеЕсли Оп = "date" Тогда Возврат РТ.op_date(А[0]);
+	ИначеЕсли Оп = "sym" Тогда Возврат РТ.op_sym(А[0]);
+	ИначеЕсли Оп = "mul" Тогда Возврат РТ.op_mul(А[0], А[1]);
+	ИначеЕсли Оп = "add" Тогда Возврат РТ.op_add(А[0], А[1]);
+	ИначеЕсли Оп = "sub" Тогда Возврат РТ.op_sub(А[0], А[1]);
+	ИначеЕсли Оп = "div" Тогда Возврат РТ.op_div(А[0], А[1]);
+	ИначеЕсли Оп = "mod" Тогда Возврат РТ.op_mod(А[0], А[1]);
+	ИначеЕсли Оп = "min" Тогда Возврат РТ.op_min(А[0], А[1]);
+	ИначеЕсли Оп = "max" Тогда Возврат РТ.op_max(А[0], А[1]);
+	ИначеЕсли Оп = "abs" Тогда Возврат РТ.op_abs(А[0]);
+	ИначеЕсли Оп = "pow" Тогда Возврат РТ.op_pow(А[0], А[1]);
+	ИначеЕсли Оп = "round" Тогда Возврат РТ.op_round(А[0], А[1], А[2]);
+	ИначеЕсли Оп = "cmp" Тогда Возврат РТ.op_cmp(А[0], А[1], А[2]);
+	ИначеЕсли Оп = "eq" Тогда Возврат РТ.op_eq(А[0], А[1]);
+	ИначеЕсли Оп = "keyEq" Тогда Возврат РТ.op_key(А[0]) = РТ.op_key(А[1]);
+	ИначеЕсли Оп = "legalTime" Тогда Возврат РТ.op_legalTime();
+	ИначеЕсли Оп = "setLegalTime" Тогда
+		РТ.op_setLegalTime(А[0]);
+		Возврат Неопределено;
+	КонецЕсли;
+	ВызватьИсключение "неизвестная операция фикстуры: " + Оп;
+КонецФункции
+
+Каталог = ТекущийСценарий().Каталог;
+ПодключитьСценарий(ОбъединитьПути(Каталог, "json.bsl"), "JsonL0");
+ПодключитьСценарий(ОбъединитьПути(Каталог, "runtime.bsl"), "РантаймL0");
+J = Новый JsonL0();
+РТ = Новый РантаймL0();
+Выход = "";
+Для Каждого Случай Из J.Прочитать(АргументыКоманднойСтроки[0]).Получить("cases") Цикл
+	Попытка
+		Получено = Отобразить(Исполнить(Случай));
+	Исключение
+		ТекстОтказа = РТ.ТекстОтказа(ИнформацияОбОшибке().Описание);
+		Если ТекстОтказа = Неопределено Тогда
+			ВызватьИсключение;
+		КонецЕсли;
+		Получено = "{""refused"":" + J.ТекстJSON(ТекстОтказа) + "}";
+	КонецПопытки;
+	Запись = "{""id"":" + J.ТекстJSON(Случай.Получить("id")) + ",""got"":" + Получено + "}";
+	Выход = ?(Выход = "", Запись, Выход + "," + Запись);
+КонецЦикла;
+Сообщить("[" + Выход + "]");

arxo_codegen/targets/bsl/emit.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+"""Эмиттер встроенного языка 1С (BSL). Тот же план, другой синтаксис и тот же
+контракт рантайма; исполнитель в воротах — OneScript (`oscript`), без
+лицензии платформы.
+
+Модель — класс `МодельL0`, подключаемый раннером через `ПодключитьСценарий`:
+строки таблиц лежат в `Массив` в порядке вставки (`Соответствие` служит только
+поиском по ключу), операции рантайма зовутся с префиксом `op_`. BSL не
+различает регистр и имеет ключевые слова в двух алфавитах, поэтому имена из
+плана манглируются префиксом до латинских букв, цифр и `_` и сверяются на
+уникальность без учёта регистра.
+"""
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+# Исходники BSL принято хранить с BOM; на печать раннера он не попадает (проба
+# OneScript 2.2.0: stdout — UTF-8 без BOM).
+BOM = "\ufeff"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def s(text: str) -> str:
+    """Строковый литерал BSL: кавычка удваивается, экранов `\\` в языке нет,
+    поэтому управляющие символы идут вызовом `Символ(код)`."""
+    parts, buf = [], []
+    for ch in text:
+        if ord(ch) < 32 or ord(ch) == 127 or ch in "\u2028\u2029":
+            if buf:
+                parts.append('"' + "".join(buf) + '"')
+                buf = []
+            parts.append(f"Символ({ord(ch)})")
+        else:
+            buf.append('""' if ch == '"' else ch)
+    if buf or not parts:
+        parts.append('"' + "".join(buf) + '"')
+    return " + ".join(parts)
+
+
+def ident(prefix: str, name: str, used: dict) -> str:
+    """Имя в порождённом коде: префикс плюс имя плана до [A-Za-z0-9_].
+    Совпадение без учёта регистра — внутренняя ошибка эмиттера, не отказ: имя
+    плана несёт порядковый номер правила и уникально."""
+    out = prefix + re.sub(r"[^A-Za-z0-9_]", "_", name)
+    fold = out.casefold()
+    if fold in used:
+        raise AssertionError(f"эмиттер bsl: имена {used[fold]!r} и {name!r} совпали без учёта регистра")
+    used[fold] = name
+    return out
+
+
+def literal(t: dict) -> str:
+    if t["t"] == "money":
+        return f'РТ.op_money({s(t["v"])}, {s(t["cur"])})'
+    if t["t"] == "dec":
+        return f'РТ.op_dec({s(t["v"])})'
+    if t["t"] == "date":
+        return f'РТ.op_date({s(t["v"])})'
+    if t["t"] == "enum":
+        return f'РТ.op_sym({s(t["v"])})'
+    return s(t["v"])
+
+
+def term(t: dict, lits: dict | None = None) -> str:
+    """Выражение терма. С `lits` литерал выносится в локальную переменную
+    правила: разбор длинного целого в интерпретаторе дорог, а во внутреннем
+    цикле соединения он повторялся на каждой строке. Литерал отказа не даёт и
+    после построения не изменяется, поэтому вынос ответа не меняет."""
+    k = t["k"]
+    if k == "var":
+        return f'Стр{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        code = literal(t)
+        if lits is None or t["t"] == "text":
+            return code
+        return lits.setdefault(code, f"Лит{len(lits)}")
+    if k == "bin":
+        return f'РТ.op_{t["op"]}({term(t["l"], lits)}, {term(t["r"], lits)})'
+    if k == "call":
+        return f'РТ.op_{t["fn"]}(' + ", ".join(term(a, lits) for a in t["args"]) + ')'
+    raise AssertionError(k)
+
+
+def row(L: list, ind: str, var: str, args: list, lits: dict | None = None) -> None:
+    """Массив значений: литералов массива в BSL нет, аргументы вычисляются по
+    порядку, как у остальных целей."""
+    L.append(f"{ind}{var} = Новый Массив;")
+    for a in args:
+        L.append(f"{ind}{var}.Добавить({term(a, lits)});")
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = [f"// Порождено targets/bsl/emit.py из плана {SUPPORTED_PLAN}; пакет {plan['package'].get('name')}.",
+         "Перем РТ;", "Перем Таблицы;", "Перем Виденные;", "Перем ТаблПараметры;", "Перем ТаблКонстанты;",
+         "Перем ТаблБазы;", "Перем Ключи;", "Перем ЧитателиКлючей;", ""]
+    L.append("Процедура Начать(Рантайм) Экспорт")
+    L.append("\tРТ = Рантайм;")
+    L.append("\tТаблицы = Новый Соответствие;")
+    L.append("\tВиденные = Новый Соответствие;")
+    for t in plan["tables"]:
+        L.append(f'\tТаблицы.Вставить({s(t["pred"])}, Новый Массив);')
+    L.append("\t// Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("\tТаблПараметры = Новый Соответствие;")
+    for t in plan["tables"]:
+        L.append("\tПар = Новый Массив;")
+        for p in t["params"]:
+            L.append(f"\tПар.Добавить({s(p)});")
+        L.append(f'\tТаблПараметры.Вставить({s(t["pred"])}, Пар);')
+    L.append("\t// Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("\tТаблКонстанты = Новый Соответствие;")
+    for cid, c in plan["consts"].items():
+        L.append(f'\tТаблКонстанты.Вставить({s(cid)}, Новый Структура("Тип, Значение", {s(c["type"])}, {term(c["term"])}));')
+    L.append("\t// Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("\tТаблБазы = Новый Соответствие;")
+    for sub, base in plan["bases"].items():
+        L.append(f"\tТаблБазы.Вставить({s(sub)}, {s(base)});")
+    L.append("\t// Ключи отношений §45.1: позиции столбцов каждого ключа, в порядке плана.")
+    L.append("\tКлючи = Новый Массив;")
+    for t in plan["tables"]:
+        for key in t["keys"]:
+            L.append("\tПоз = Новый Массив;")
+            for i in key:
+                L.append(f"\tПоз.Добавить({int(i)});")
+            L.append(f'\tКлючи.Добавить(Новый Структура("Пред, Позиции", {s(t["pred"])}, Поз));')
+    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("\t// E-0210/E-0242: прямые читатели отношения с ключом.")
+    L.append("\tЧитателиКлючей = Новый Соответствие;")
+    for source, consumers in sorted(readers.items()):
+        L.append("\tЧитатели = Новый Массив;")
+        for consumer in sorted(consumers):
+            L.append(f"\tЧитатели.Добавить({s(consumer)});")
+        L.append(f"\tЧитателиКлючей.Вставить({s(source)}, Читатели);")
+    L.append("\t// Собственные факты пакета кладутся до фактов дела.")
+    for f in plan["facts"]:
+        row(L, "\t", "Ряд", f["args"])
+        L.append(f'\tДобавитьСтроку({s(f["pred"])}, Ряд);')
+    L.append("КонецПроцедуры")
+    L.append("")
+    L.append("Функция Строки(Пред) Экспорт")
+    L.append("\tТ = Таблицы.Получить(Пред);")
+    L.append("\tВозврат ?(Т = Неопределено, Новый Массив, Т);")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Функция Параметры(Пред) Экспорт")
+    L.append("\tВозврат ТаблПараметры.Получить(Пред);")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Функция Константа(Ид) Экспорт")
+    L.append("\tВозврат ТаблКонстанты.Получить(Ид);")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Функция База(ИмяТипа) Экспорт")
+    L.append("\tВозврат ТаблБазы.Получить(ИмяТипа);")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Функция ЧитателиКлюча(Пред) Экспорт")
+    L.append("\tВозврат ЧитателиКлючей.Получить(Пред);")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("// Строка уникальна по ключу строки в своей таблице; порядок таблицы — порядок вставки.")
+    L.append("Функция ДобавитьСтроку(Пред, Ряд)")
+    L.append("\tМн = Виденные.Получить(Пред);")
+    L.append("\tЕсли Мн = Неопределено Тогда")
+    L.append("\t\tМн = Новый Соответствие;")
+    L.append("\t\tВиденные.Вставить(Пред, Мн);")
+    L.append("\tКонецЕсли;")
+    L.append("\tКл = РТ.op_key(Ряд);")
+    L.append("\tЕсли Мн.Получить(Кл) <> Неопределено Тогда")
+    L.append("\t\tВозврат Ложь;")
+    L.append("\tКонецЕсли;")
+    L.append("\tМн.Вставить(Кл, Истина);")
+    L.append("\tТаблицы.Получить(Пред).Добавить(Ряд);")
+    L.append("\tВозврат Истина;")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Процедура Зарегистрировать(Пред, Ряд) Экспорт")
+    L.append("\tДобавитьСтроку(Пред, Ряд);")
+    L.append("КонецПроцедуры")
+    L.append("")
+    used: dict = {}
+    names = []
+    for r in plan["rules"]:
+        fn = ident("Правило_", r["name"], used)
+        names.append(fn)
+        L.append(f'// {r["id"]}')
+        L.append(f"Функция {fn}()")
+        L.append("\tРост = Ложь;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'\tЕсли РТ.ПорядокТекста(РТ.op_legalTime(), {s(r["window"]["start"])}) < 0 Тогда')
+                L.append("\t\tВозврат Ложь;")
+                L.append("\tКонецЕсли;")
+            if r["window"].get("end"):
+                L.append(f'\tЕсли РТ.ПорядокТекста(РТ.op_legalTime(), {s(r["window"]["end"])}) >= 0 Тогда')
+                L.append("\t\tВозврат Ложь;")
+                L.append("\tКонецЕсли;")
+        lit_at = len(L)
+        lits: dict = {}
+        # Проверки в порядке плана: соединения, фильтры, гарды. Интерпретатор
+        # перебирает декартово произведение атомов на порядки медленнее Python
+        # (kz.corpus.bin: пять атомов, 43 с на дело), поэтому ПРЕФИКС проверок,
+        # которые отказать не могут, стоит в цикле, где связаны их строки:
+        # фильтр — `eq` рантайма, соединение — `eq` не над Money (у денег
+        # отказ по валютам). Первая проверка, способная отказать, и всё после
+        # неё остаются во внутреннем цикле в прежнем порядке. Отсеянное префиксом
+        # сочетание во внутреннем цикле тоже отсеялось бы до первой отказывающей
+        # проверки; строки головы добавляются в том же порядке — ответ и отказы
+        # те же.
+        inner = len(r["atoms"]) - 1
+        checks, prefix = [], True
+        for (ai, aj, at), (bi, bj, bt) in r["joins"]:
+            prefix = prefix and at != "money" and bt != "money"
+            checks.append((max(ai, bi) if prefix else inner, f'РТ.op_cmp(Стр{ai}[{aj}], "eq", Стр{bi}[{bj}])'))
+        for f in r["filters"]:
+            checks.append((f["row"] if prefix else inner, f'РТ.op_eq(Стр{f["row"]}[{f["col"]}], {term(f["term"], lits)})'))
+        for g in r["guards"]:
+            checks.append((inner, f'РТ.op_cmp({term(g["l"], lits)}, {s(g["op"])}, {term(g["r"], lits)})'))
+        ind = "\t"
+        for i, a in enumerate(r["atoms"]):
+            # Число строк снимается на входе в цикл: добавленные внутри правила строки
+            # идут в конец массива и в этот проход не попадают (как `.dup` у Ruby).
+            L.append(f'{ind}Т{i} = Таблицы.Получить({s(a["pred"])});')
+            L.append(f"{ind}Кол{i} = Т{i}.Количество();")
+            L.append(f"{ind}Для Инд{i} = 0 По Кол{i} - 1 Цикл")
+            ind += "\t"
+            L.append(f"{ind}Стр{i} = Т{i}[Инд{i}];")
+            for level, c in checks:
+                if level == i:
+                    L.append(f"{ind}Если Не {c} Тогда")
+                    L.append(f"{ind}\tПродолжить;")
+                    L.append(f"{ind}КонецЕсли;")
+        row(L, ind, "Гол", r["head"]["args"], lits)
+        L.append(f'{ind}Если ДобавитьСтроку({s(r["head"]["pred"])}, Гол) Тогда')
+        L.append(f"{ind}\tРост = Истина;")
+        L.append(f"{ind}КонецЕсли;")
+        for _ in r["atoms"]:
+            ind = ind[:-1]
+            L.append(f"{ind}КонецЦикла;")
+        L[lit_at:lit_at] = [f"\t{var} = {code};" for code, var in lits.items()]
+        L.append("\tВозврат Рост;")
+        L.append("КонецФункции")
+        L.append("")
+    L.append("Процедура Насытить() Экспорт")
+    L.append("\tРост = Истина;")
+    L.append("\tПока Рост Цикл")
+    L.append("\t\tРост = Ложь;")
+    for fn in names:
+        L.append(f"\t\tЕсли {fn}() Тогда")
+        L.append("\t\t\tРост = Истина;")
+        L.append("\t\tКонецЕсли;")
+    L.append("\tКонецЦикла;")
+    L.append("КонецПроцедуры")
+    L.append("")
+    L.append("// KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("Функция КонфликтыКлючей() Экспорт")
+    L.append("\tН = 0;")
+    L.append("\tДля Каждого Ключ Из Ключи Цикл")
+    L.append("\t\tГруппы = Новый Соответствие;")
+    L.append("\t\tДля Каждого Р Из Таблицы.Получить(Ключ.Пред) Цикл")
+    L.append("\t\t\tПроекция = Новый Массив;")
+    L.append("\t\t\tДля Каждого Поз Из Ключ.Позиции Цикл")
+    L.append("\t\t\t\tПроекция.Добавить(Р[Поз]);")
+    L.append("\t\t\tКонецЦикла;")
+    L.append("\t\t\tКл = РТ.op_key(Проекция);")
+    L.append("\t\t\tСчёт = Группы.Получить(Кл);")
+    L.append("\t\t\tГруппы.Вставить(Кл, ?(Счёт = Неопределено, 0, Счёт) + 1);")
+    L.append("\t\tКонецЦикла;")
+    L.append("\t\tДля Каждого Гр Из Группы Цикл")
+    L.append("\t\t\tЕсли Гр.Значение > 1 Тогда")
+    L.append("\t\t\t\tН = Н + 1;")
+    L.append("\t\t\tКонецЕсли;")
+    L.append("\t\tКонецЦикла;")
+    L.append("\tКонецЦикла;")
+    L.append("\tВозврат Н;")
+    L.append("КонецФункции")
+    L.append("")
+    L.append("Функция КонфликтныеПредикатыКлючей() Экспорт")
+    L.append("\tОтвет = Новый Массив;")
+    L.append("\tВидено = Новый Соответствие;")
+    L.append("\tДля Каждого Ключ Из Ключи Цикл")
+    L.append("\t\tГруппы = Новый Соответствие;")
+    L.append("\t\tДля Каждого Р Из Таблицы.Получить(Ключ.Пред) Цикл")
+    L.append("\t\t\tПроекция = Новый Массив;")
+    L.append("\t\t\tДля Каждого Поз Из Ключ.Позиции Цикл")
+    L.append("\t\t\t\tПроекция.Добавить(Р[Поз]);")
+    L.append("\t\t\tКонецЦикла;")
+    L.append("\t\t\tКл = РТ.op_key(Проекция);")
+    L.append("\t\t\tСчёт = Группы.Получить(Кл);")
+    L.append("\t\t\tГруппы.Вставить(Кл, ?(Счёт = Неопределено, 0, Счёт) + 1);")
+    L.append("\t\tКонецЦикла;")
+    L.append("\t\tЕсть = Ложь;")
+    L.append("\t\tДля Каждого Гр Из Группы Цикл")
+    L.append("\t\t\tЕсли Гр.Значение > 1 Тогда")
+    L.append("\t\t\t\tЕсть = Истина;")
+    L.append("\t\t\t\tПрервать;")
+    L.append("\t\t\tКонецЕсли;")
+    L.append("\t\tКонецЦикла;")
+    L.append("\t\tЕсли Есть И Видено.Получить(Ключ.Пред) = Неопределено Тогда")
+    L.append("\t\t\tВидено.Вставить(Ключ.Пред, Истина);")
+    L.append("\t\t\tОтвет.Добавить(Ключ.Пред);")
+    L.append("\t\tКонецЕсли;")
+    L.append("\tКонецЦикла;")
+    L.append("\tВозврат Ответ;")
+    L.append("КонецФункции")
+    return BOM + "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "bsl"
+MODEL = "model.bsl"
+MAINS = {"runner": "runner.bsl", "cert": "cert.bsl"}
+
+
+def available():
+    os_ = shutil.which("oscript")
+    return (True, os_) if os_ else (False, "нет oscript в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("json.bsl", "runtime.bsl", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    return None
+
+
+def run(proj, main: str):
+    return ["oscript", str(Path(proj) / MAINS[main])], None
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(HERE.parents[1]))
+    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")