arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/cs/emit.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""Эмиттер C#. Модель — статический класс `Model`; проект — один csproj с
+`Program.cs` (раннер либо харнесс), `Runtime.cs` и `Model.cs`."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def jstr(s: str) -> str:
+    return json.dumps(s, ensure_ascii=False)
+
+
+def key_readers(plan: dict) -> dict[str, list[str]]:
+    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"])
+    return {source: sorted(consumers) for source, consumers in sorted(readers.items())}
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money({jstr(t["v"])}, {jstr(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT.dec({jstr(t["v"])})'
+        if t["t"] == "date":
+            return f'RT.date({jstr(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT.sym({jstr(t["v"])})'
+        return jstr(t["v"])
+    if k == "bin":
+        return f'RT.{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'RT.round({term(args[0])}, {term(args[1])}, {jstr(args[2]["v"])})'
+        return f'RT.{t["fn"]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["public static class Model",
+         "{",
+         "    public static readonly Dictionary<string, List<List<object>>> TABLES = new();",
+         "    // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).",
+         "    public static readonly Dictionary<string, string[]> PARAMS = new();",
+         "    // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.",
+         "    public static readonly Dictionary<string, (string, object)> CONSTS = new();",
+         "    // Наследование сущностей: подтип подходит параметру базового типа.",
+         "    public static readonly Dictionary<string, string> BASES = new();",
+         "    // Ключи отношений §45.1: позиции столбцов каждого ключа.",
+         "    public static readonly Dictionary<string, int[][]> KEYS = new();",
+         "    // E-0210/E-0242: читатели конфликтного отношения в плане.",
+         "    public static readonly Dictionary<string, string[]> KEY_READERS = new();",
+         "    static readonly HashSet<string> Seen = new();",
+         "",
+         "    static Model()",
+         "    {"]
+    for t in plan["tables"]:
+        L.append(f'        TABLES[{jstr(t["pred"])}] = new List<List<object>>();')
+        L.append(f'        PARAMS[{jstr(t["pred"])}] = new string[] {{ ' + ", ".join(jstr(p) for p in t["params"]) + " };")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'        KEYS[{jstr(t["pred"])}] = new int[][] {{ ' + ", ".join("new int[] { " + ", ".join(str(i) for i in k) + " }" for k in t["keys"]) + " };")
+    for source, consumers in key_readers(plan).items():
+        L.append(f'        KEY_READERS[{jstr(source)}] = new string[] {{ ' + ", ".join(jstr(value) for value in consumers) + " };")
+    for cid, c in plan["consts"].items():
+        L.append(f'        CONSTS[{jstr(cid)}] = ({jstr(c["type"])}, {term(c["term"])});')
+    for sub, base in plan["bases"].items():
+        L.append(f'        BASES[{jstr(sub)}] = {jstr(base)};')
+    L.append("    }")
+    L.append("")
+    L.append("    // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("    public static int KeyConflicts()")
+    L.append("    {")
+    L.append("        int n = 0;")
+    L.append("        foreach (var e in KEYS)")
+    L.append("        {")
+    L.append("            foreach (var key in e.Value)")
+    L.append("            {")
+    L.append("                var groups = new Dictionary<string, int>();")
+    L.append("                foreach (var row in TABLES[e.Key])")
+    L.append("                {")
+    L.append("                    var p = RT.key(key.Select(i => row[i]).ToList());")
+    L.append("                    groups[p] = groups.TryGetValue(p, out var c) ? c + 1 : 1;")
+    L.append("                }")
+    L.append("                n += groups.Values.Count(c => c > 1);")
+    L.append("            }")
+    L.append("        }")
+    L.append("        return n;")
+    L.append("    }")
+    L.append("    public static HashSet<string> KeyConflictPredicates()")
+    L.append("    {")
+    L.append("        var outp = new HashSet<string>();")
+    L.append("        foreach (var e in KEYS) foreach (var key in e.Value)")
+    L.append("        { var groups = new Dictionary<string, int>(); foreach (var row in TABLES[e.Key]) { var p = RT.key(key.Select(i => row[i]).ToList()); groups[p] = groups.TryGetValue(p, out var c) ? c + 1 : 1; } if (groups.Values.Any(c => c > 1)) outp.Add(e.Key); }")
+    L.append("        return outp;")
+    L.append("    }")
+    L.append("")
+    L.append("    static bool AddRow(string urn, List<object> row)")
+    L.append("    {")
+    L.append('        if (!Seen.Add(urn + "#" + RT.key(row))) return false;')
+    L.append("        TABLES[urn].Add(row);")
+    L.append("        return true;")
+    L.append("    }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'    // {r["id"]}')
+        L.append(f'    static bool Rule_{r["name"]}()')
+        L.append("    {")
+        L.append("        bool grew = false;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'        if (string.CompareOrdinal(RT.legalTime(), {jstr(r["window"]["start"])}) < 0) return false;')
+            if r["window"].get("end"):
+                L.append(f'        if (string.CompareOrdinal(RT.legalTime(), {jstr(r["window"]["end"])}) >= 0) return false;')
+        ind = "        "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}foreach (var r{i} in TABLES[{jstr(a["pred"])}].ToList())')
+            L.append(f'{ind}{{')
+            ind += "    "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}if (!RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}])) continue;')
+        for f in r["filters"]:
+            L.append(f'{ind}if (!RT.eq(r{f["row"]}[{f["col"]}], {term(f["term"])})) continue;')
+        for g in r["guards"]:
+            L.append(f'{ind}if (!RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})) continue;')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if (AddRow({jstr(r["head"]["pred"])}, RT.row({args}))) grew = true;')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("        return grew;")
+        L.append("    }")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("    public static void Saturate()")
+    L.append("    {")
+    L.append("        bool grew = true;")
+    L.append("        while (grew)")
+    L.append("        {")
+    L.append("            grew = false;")
+    for n in names:
+        L.append(f"            if (Rule_{n}()) grew = true;")
+    L.append("        }")
+    L.append("    }")
+    L.append("")
+    L.append("    public static void Register(string urn, List<object> row) => AddRow(urn, row);")
+    L.append("")
+    L.append("    public static void PackageFacts()")
+    L.append("    {")
+    for f in plan["facts"]:
+        L.append(f'        AddRow({jstr(f["pred"])}, RT.row(' + ", ".join(term(a) for a in f["args"]) + "));")
+    L.append("    }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "cs"
+MODEL = "Model.cs"
+MAINS = {"runner": "Runner.cs", "cert": "Cert.cs"}
+CSPROJ = '''<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <AssemblyName>app</AssemblyName>
+    <RootNamespace>lawgen</RootNamespace>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
+  </PropertyGroup>
+</Project>
+'''
+
+
+def available():
+    dotnet = shutil.which("dotnet")
+    return (True, dotnet) if dotnet else (False, "нет dotnet в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    shutil.copyfile(HERE / "Runtime.cs", proj / "Runtime.cs")
+    shutil.copyfile(HERE / MAINS[main], proj / "Program.cs")
+    (proj / "app.csproj").write_text(CSPROJ, encoding="utf-8")
+    out += [proj / "Runtime.cs", proj / "Program.cs", proj / "app.csproj"]
+    return out
+
+
+def build(proj):
+    return ["dotnet", "build", "-nologo", "-v", "q", "-c", "Release"], str(proj)
+
+
+def run(proj, main: str):
+    return ["dotnet", str(Path(proj) / "bin" / "Release" / "net10.0" / "app.dll")], 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")

arxo_codegen/targets/dart/cert.dart

@@ -0,0 +1,99 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+import 'dart:io';
+
+import 'json.dart' as J;
+import 'runtime.dart';
+
+Object lit(Object? x) {
+  if (x is String) return x;
+  final m = x as Map<String, Object?>;
+  if (m.containsKey('dec')) return RT.dec(m['dec'] as String);
+  if (m.containsKey('money')) return RT.money(m['money'] as String, m['cur'] as String);
+  if (m.containsKey('text')) return m['text'] as String;
+  if (m.containsKey('date')) return RT.date(m['date'] as String);
+  if (m.containsKey('sym')) return RT.sym(m['sym'] as String);
+  if (m.containsKey('row')) return (m['row'] as List).map(lit).toList();
+  throw StateError('литерал фикстуры: $x');
+}
+
+// Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+String digits(BigInt u, int s) {
+  final body = u.abs().toString().padLeft(s + 1, '0');
+  final text = s == 0 ? body : '${body.substring(0, body.length - s)}.${body.substring(body.length - s)}';
+  return (u.isNegative ? '-' : '') + text;
+}
+
+String render(Object? v) {
+  if (v == null) return 'null';
+  if (v is bool) return '$v';
+  if (v is String) return J.str(v);
+  if (v is Money) return J.str('${digits(v.u, v.s)} ${v.cur}');
+  if (v is LDate) return J.str(v.v);
+  if (v is Sym) return J.str(v.id);
+  final d = v as Dec;
+  return J.str(digits(d.u, d.s));
+}
+
+Object? run(String op, List<Object> a) {
+  switch (op) {
+    case 'dec':
+      return RT.dec(a[0] as String);
+    case 'money':
+      return RT.money(a[0] as String, a[1] as String);
+    case 'date':
+      return RT.date(a[0] as String);
+    case 'sym':
+      return RT.sym(a[0] as String);
+    case 'mul':
+      return RT.mul(a[0], a[1]);
+    case 'add':
+      return RT.add(a[0], a[1]);
+    case 'sub':
+      return RT.sub(a[0], a[1]);
+    case 'div':
+      return RT.div(a[0], a[1]);
+    case 'mod':
+      return RT.mod(a[0], a[1]);
+    case 'min':
+      return RT.min(a[0], a[1]);
+    case 'max':
+      return RT.max(a[0], a[1]);
+    case 'abs':
+      return RT.abs(a[0]);
+    case 'pow':
+      return RT.pow(a[0], a[1]);
+    case 'round':
+      return RT.round(a[0], a[1], a[2] as String);
+    case 'cmp':
+      return RT.cmp(a[0], a[1] as String, a[2]);
+    case 'eq':
+      return RT.eq(a[0], a[1]);
+    case 'keyEq':
+      return RT.key((a[0] as List).cast<Object>()) == RT.key((a[1] as List).cast<Object>());
+    case 'legalTime':
+      return RT.legalTime();
+    case 'setLegalTime':
+      RT.setLegalTime(a[0] as String);
+      return null;
+  }
+  throw StateError('неизвестная операция фикстуры: $op');
+}
+
+void main(List<String> argv) {
+  final fixture = J.readJson(argv[0]) as Map<String, Object?>;
+  final out = <String>[];
+  for (final c in (fixture['cases'] as List).cast<Map<String, Object?>>()) {
+    final args = (c['args'] as List).map(lit).toList();
+    String got;
+    try {
+      got = render(run(c['op'] as String, args));
+    } on Refused catch (e) {
+      got = '{"refused":${J.str(e.message)}}';
+    }
+    out.add('{"id":${J.str(c['id'] as String)},"got":$got}');
+  }
+  J.emitLine('[${out.join(',')}]');
+  exitCode = 0;
+  stdout.flush();
+}

arxo_codegen/targets/dart/emit.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Эмиттер Dart. Тот же план и тот же контракт рантайма. У Dart нет кода
+верхнего уровня, поэтому собственные факты пакета — функция `packageFacts`,
+которую раннер зовёт до фактов дела."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def ds(s: str) -> str:
+    """Строковый литерал Dart: экраны JSON Dart понимает, а `$` — интерполяция."""
+    return json.dumps(s, ensure_ascii=False).replace("$", "\\$")
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money({ds(t["v"])}, {ds(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT.dec({ds(t["v"])})'
+        if t["t"] == "date":
+            return f'RT.date({ds(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT.sym({ds(t["v"])})'
+        return ds(t["v"])
+    if k == "bin":
+        return f'RT.{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'RT.round({term(args[0])}, {term(args[1])}, {ds(args[2]["v"])})'
+        return f'RT.{t["fn"]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["// ignore_for_file: non_constant_identifier_names, unused_local_variable, prefer_const_constructors",
+         "import 'runtime.dart';", "",
+         "final Map<String, List<List<Object>>> TABLES = {"]
+    for t in plan["tables"]:
+        L.append(f'  {ds(t["pred"])}: <List<Object>>[],')
+    L.append("};")
+    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("const Map<String, List<String>> KEY_READERS = {")
+    for source, consumers in sorted(readers.items()):
+        L.append(f'  {ds(source)}: <String>[' + ", ".join(ds(value) for value in sorted(consumers)) + "],")
+    L.append("};")
+    L.append("// Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("const Map<String, List<String>> PARAMS = {")
+    for t in plan["tables"]:
+        L.append(f'  {ds(t["pred"])}: <String>[' + ", ".join(ds(p) for p in t["params"]) + "],")
+    L.append("};")
+    L.append("// Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("final Map<String, List<Object>> CONSTS = {")
+    for cid, c in plan["consts"].items():
+        L.append(f'  {ds(cid)}: <Object>[{ds(c["type"])}, {term(c["term"])}],')
+    L.append("};")
+    L.append("// Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("const Map<String, String> BASES = {")
+    for sub, base in plan["bases"].items():
+        L.append(f"  {ds(sub)}: {ds(base)},")
+    L.append("};")
+    L.append("// Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("const Map<String, List<List<int>>> KEYS = {")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'  {ds(t["pred"])}: {json.dumps(t["keys"])},')
+    L.append("};")
+    L.append("final Map<String, Set<String>> _seen = {};")
+    L.append("")
+    L.append("bool addRow(String urn, List<Object> row) {")
+    L.append("  if (!_seen.putIfAbsent(urn, () => <String>{}).add(RT.key(row))) return false;")
+    L.append("  TABLES[urn]!.add(row);")
+    L.append("  return true;")
+    L.append("}")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'// {r["id"]}')
+        L.append(f'bool rule_{r["name"]}() {{')
+        L.append("  var grew = false;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'  if (RT.legalTime().compareTo({ds(r["window"]["start"])}) < 0) return false;')
+            if r["window"].get("end"):
+                L.append(f'  if (RT.legalTime().compareTo({ds(r["window"]["end"])}) >= 0) return false;')
+        ind = "  "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}for (final r{i} in List.of(TABLES[{ds(a["pred"])}]!)) {{')
+            ind += "  "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}if (!RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}])) continue;')
+        for f in r["filters"]:
+            L.append(f'{ind}if (!RT.eq(r{f["row"]}[{f["col"]}], {term(f["term"])})) continue;')
+        for g in r["guards"]:
+            L.append(f'{ind}if (!RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})) continue;')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if (addRow({ds(r["head"]["pred"])}, <Object>[{args}])) grew = true;')
+        for _ in r["atoms"]:
+            ind = ind[:-2]
+            L.append(ind + "}")
+        L.append("  return grew;")
+        L.append("}")
+        L.append("")
+    L.append("void saturate() {")
+    L.append("  var grew = true;")
+    L.append("  while (grew) {")
+    L.append("    grew = false;")
+    for r in plan["rules"]:
+        L.append(f'    if (rule_{r["name"]}()) grew = true;')
+    L.append("  }")
+    L.append("}")
+    L.append("")
+    L.append("bool register(String urn, List<Object> row) => addRow(urn, row);")
+    L.append("")
+    L.append("// KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("int keyConflicts() {")
+    L.append("  var n = 0;")
+    L.append("  KEYS.forEach((urn, keys) {")
+    L.append("    for (final key in keys) {")
+    L.append("      final groups = <String, int>{};")
+    L.append("      for (final row in TABLES[urn]!) {")
+    L.append("        final g = RT.key([for (final i in key) row[i]]);")
+    L.append("        groups[g] = (groups[g] ?? 0) + 1;")
+    L.append("      }")
+    L.append("      n += groups.values.where((c) => c > 1).length;")
+    L.append("    }")
+    L.append("  });")
+    L.append("  return n;")
+    L.append("}")
+    L.append("")
+    L.append("Set<String> keyConflictPredicates() {")
+    L.append("  final out = <String>{};")
+    L.append("  KEYS.forEach((urn, keys) {")
+    L.append("    for (final key in keys) {")
+    L.append("      final groups = <String, int>{};")
+    L.append("      for (final row in TABLES[urn]!) { final g = RT.key([for (final i in key) row[i]]); groups[g] = (groups[g] ?? 0) + 1; }")
+    L.append("      if (groups.values.any((c) => c > 1)) out.add(urn);")
+    L.append("    }")
+    L.append("  });")
+    L.append("  return out;")
+    L.append("}")
+    L.append("")
+    L.append("// Собственные факты пакета: у Dart нет кода верхнего уровня, раннер зовёт это до фактов дела.")
+    L.append("void packageFacts() {")
+    for f in plan["facts"]:
+        L.append(f'  addRow({ds(f["pred"])}, <Object>[' + ", ".join(term(a) for a in f["args"]) + "]);")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "dart"
+MODEL = "model.dart"
+MAINS = {"runner": "runner.dart", "cert": "cert.dart"}
+
+
+def available():
+    dart = shutil.which("dart")
+    return (True, dart) if dart else (False, "нет dart в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.dart", "json.dart", 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 ["dart", "run", 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")