arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/test_api_contract.py

@@ -0,0 +1,89 @@
+"""DECISION-0423: контракт API порождённой библиотеки Python.
+
+Один ответ `Answer` у L0 и L1, значения входа — литерал-термы §53, сверка §189
+в общем входе `evaluate` (API отвечает так же, как раннер), ошибка формы вызова —
+`InputError`, состояние — на вызов (потоки не делят таблиц модели)."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import deliver  # noqa: E402
+import plan  # noqa: E402
+from test_support import fixture_root  # noqa: E402
+
+PROBE = r'''
+import json, threading, api
+from decimal import Decimal
+out = {}
+base = [api.fact_ransom_offered_to("старик"), api.fact_released_without_ransom("старик")]
+wish = lambda w: [api.fact_wished("старуха", w), api.fact_conveyed_to_fish("старик", w)]
+a = api.ask_obliged_to_grant(base + wish("корыто"), "2026-09-28", "корыто")
+out["answer"] = [a.result_kind, a.truth_status, a.evaluation_status, list(a.issues)]
+d = api.decimal("10")
+bad = api.ask_obliged_to_grant([api.fact_ransom_offered_to(d), api.fact_released_without_ransom(d),
+                                api.fact_wished("старуха", "корыто"), api.fact_conveyed_to_fish(d, "корыто")],
+                               "2026-09-28", "корыто")
+out["wrong_type"] = [bad.truth_status, bad.evaluation_status, list(bad.issues)]
+r = api.rows_obliged_to_grant(base + wish("корыто"), "2026-09-28")
+out["rows"] = [r.result_kind, [[t.kind, t.id] for row in r.rows for t in row]]
+try:
+    api.fact_wished("старуха", Decimal("1"))
+    out["input_error"] = None
+except api.InputError as exc:
+    out["input_error"] = type(exc).__name__
+try:
+    api.ask_obliged_to_grant([], "28.09.2026", "корыто")
+    out["bad_on"] = None
+except api.InputError:
+    out["bad_on"] = "InputError"
+res = {}
+def work(n):
+    w = "корыто" if n % 2 else "изба"
+    res[n] = api.ask_obliged_to_grant(base + wish(w), "2026-09-28", "корыто").truth_status
+ts = [threading.Thread(target=work, args=(n,)) for n in range(24)]
+[t.start() for t in ts]; [t.join() for t in ts]
+out["threads"] = sorted({(n % 2, v) for n, v in res.items()})
+print(json.dumps(out, ensure_ascii=False))
+'''
+
+
+def emit(name: str, root: Path) -> Path:
+    ir = json.loads((fixture_root() / "corpus/clir" / f"{name}.lawir.json").read_text(encoding="utf-8"))
+    project = root / name
+    deliver.emit_project(plan.build_plan(ir), "py", project)
+    return project
+
+
+class ApiContractTests(unittest.TestCase):
+    def test_l1_api_answers_like_the_runner_and_isolates_calls(self):
+        with tempfile.TemporaryDirectory(prefix="api-contract-") as raw:
+            project = emit("codegen-api-defeasible", Path(raw))
+            res = subprocess.run([sys.executable, "-c", PROBE], cwd=project, capture_output=True, text=True, check=True)
+            out = json.loads(res.stdout)
+            self.assertEqual(out["answer"], ["PROPOSITION", "TRUE_ONLY", "COMPUTED", []])
+            # §189: Decimal в слоте сущности — утверждения не приняты, как у раннера и оракула.
+            self.assertEqual(out["wrong_type"], ["NEITHER", "TYPE_ERROR", ["TYPE_ERROR"] * 3])
+            self.assertEqual(out["rows"], ["COLLECTION", [["entity_ref", "корыто"]]])
+            self.assertEqual(out["input_error"], "InputError")
+            self.assertEqual(out["bad_on"], "InputError")
+            self.assertEqual(out["threads"], [[0, "NEITHER"], [1, "TRUE_ONLY"]])
+
+    def test_l0_and_l1_share_one_answer_shape(self):
+        with tempfile.TemporaryDirectory(prefix="api-contract-l0-") as raw:
+            project = emit("codegen-api-strict", Path(raw))
+            script = ("import json, api\n"
+                      "a = api.ask_derived_value([api.fact_input_value('s1')], '2026-09-28', 's1')\n"
+                      "print(json.dumps([type(a).__name__, a.result_kind, a.truth_status, a.evaluation_status, list(a.issues)]))\n")
+            res = subprocess.run([sys.executable, "-c", script], cwd=project, capture_output=True, text=True, check=True)
+            self.assertEqual(json.loads(res.stdout), ["Answer", "PROPOSITION", "TRUE_ONLY", "COMPUTED", []])
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_calendar_policy.py

@@ -0,0 +1,48 @@
+"""E-0187 changes the month_end read set, not the rest of the policy."""
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+import sys
+import unittest
+
+path = Path(__file__).resolve().parent / "targets/py/runtime.py"
+spec = importlib.util.spec_from_file_location("_calendar_policy_runtime", path)
+RT = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = RT
+spec.loader.exec_module(RT)
+
+
+class CalendarPolicyTests(unittest.TestCase):
+    def setUp(self):
+        self.policy = {"start_count": "same_day", "include_end": True,
+                       "roll": "no_roll", "cutoff": None, "month_end": "last_day_of_month"}
+        self.addCleanup(RT.set_calendar, None, None)
+
+    def test_mixed_day_and_year_share_one_policy(self):
+        RT.set_calendar(self.policy, None)
+        start = RT.Date("2024-02-29")
+        self.assertEqual("2025-02-28", RT.add_calendar_period(start, 1, "calendar_year").v)
+        self.assertEqual("2024-12-05", RT.add_calendar_period(start, 280, "calendar_day").v)
+
+    def test_day_step_does_not_silence_invalid_policy(self):
+        policies = [None, dict(self.policy, roll="next_working_day"),
+                    dict(self.policy, cutoff="12:00:00"), dict(self.policy, include_end=False),
+                    dict(self.policy, month_end="unknown"), dict(self.policy, unknown=True)]
+        for policy in policies:
+            with self.subTest(policy=policy), self.assertRaises(RT.TermError):
+                RT.set_calendar(policy, None)
+                RT.add_calendar_period(RT.Date("2024-02-29"), 280, "calendar_day")
+
+    def test_month_end_is_required_only_for_month_and_year(self):
+        policy = dict(self.policy)
+        policy.pop("month_end")
+        RT.set_calendar(policy, None)
+        self.assertEqual("2024-03-01", RT.add_calendar_period(RT.Date("2024-02-29"), 1, "calendar_day").v)
+        for unit in ("calendar_month", "calendar_year"):
+            with self.subTest(unit=unit), self.assertRaises(RT.TermError):
+                RT.add_calendar_period(RT.Date("2024-02-29"), 1, unit)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_check.py

@@ -0,0 +1,49 @@
+"""Installed check wrapper keeps runtime certification target-profiled."""
+from __future__ import annotations
+
+import io
+from pathlib import Path
+import sys
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import check  # noqa: E402
+
+
+class CheckWrapperTests(unittest.TestCase):
+    def test_profiled_certifier_preserves_gate_error_list_and_reports_selection(self):
+        gate = SimpleNamespace(
+            CERT=Path("fixture.json"),
+            D=SimpleNamespace(emit_project=object()),
+            build_projects=object(),
+            run_target=object(),
+        )
+        calls = []
+
+        def certify_target(lang, descriptor, work, fixture, emit_project, build_projects, run_target):
+            calls.append((lang, descriptor, work, fixture, emit_project, build_projects, run_target))
+            return ({"checkedFixtureIds": ["a", "b"] if lang == "py" else ["a"],
+                     "unsupportedOperations": ["rat"] if lang == "lua" else [],
+                     "unsupportedLiteralTags": ["rat"] if lang == "lua" else []},
+                    ["сертификация lua: CRASH"] if lang == "lua" else [])
+
+        check._install_profiled_certifier(gate)
+        output = io.StringIO()
+        with patch.object(check.runtime_cert, "certify_target", side_effect=certify_target), \
+             patch("sys.stdout", output):
+            errors = gate.certify({"py": "python", "lua": "lua"}, Path("work"), ["py", "lua"])
+
+        self.assertEqual(errors, ["сертификация lua: CRASH"])
+        self.assertEqual([call[0] for call in calls], ["py", "lua"])
+        self.assertTrue(all(call[3] == gate.CERT for call in calls))
+        self.assertEqual(gate.RUNTIME_CERT_REPORTS["py"]["checkedFixtureIds"], ["a", "b"])
+        self.assertIn("py: 2 cases", output.getvalue())
+        self.assertIn("lua: 1 cases; ops вне профиля: rat", output.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_check_active_canaries.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+import shutil
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import check_active_canaries
+from test_support import materialize_canaries, materialize_core_kit
+
+
+class ActiveCanaryCheckerTests(unittest.TestCase):
+    def bundle_and_kit(self, base: Path) -> tuple[Path, Path]:
+        bundle, kit = base / "bundle", base / "core-kit"
+        materialize_canaries(bundle)
+        materialize_core_kit(kit, source_commit="2" * 40)
+        return bundle, kit
+
+    def test_validates_full_export(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle, kit = self.bundle_and_kit(Path(name))
+            lines = check_active_canaries.verify(bundle, core_kit=kit)
+            self.assertEqual(6, len(lines))
+            self.assertEqual(5, sum(line.startswith("PASS ") for line in lines))
+            self.assertEqual(1, sum(line.startswith("EXPECTED_REFUSAL ") for line in lines))
+
+    def test_refuses_tampered_bundle(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle, kit = self.bundle_and_kit(Path(name))
+            target = next((bundle / "canaries").rglob("oracle.outcome.json"))
+            target.write_bytes(target.read_bytes() + b"x")
+            with self.assertRaisesRegex(check_active_canaries.CanaryError, "hash"):
+                check_active_canaries.verify(bundle, core_kit=kit, allow_partial=True)
+
+    def test_refuses_missing_inventory_hash_and_escaped_id(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle, _ = self.bundle_and_kit(Path(name))
+            manifest_path = bundle / "manifest.json"
+            manifest = json.loads(manifest_path.read_text())
+            manifest["canaries"][0]["files"].pop("query.json")
+            manifest_path.write_text(json.dumps(manifest))
+            with self.assertRaisesRegex(check_active_canaries.CanaryError, "provenance"):
+                check_active_canaries.load(bundle)
+        with tempfile.TemporaryDirectory() as name:
+            bundle, _ = self.bundle_and_kit(Path(name))
+            manifest_path = bundle / "manifest.json"
+            manifest = json.loads(manifest_path.read_text())
+            manifest["canaries"][0]["id"] = "../escape"
+            manifest_path.write_text(json.dumps(manifest))
+            with self.assertRaisesRegex(check_active_canaries.CanaryError, "unsafe canary id"):
+                check_active_canaries.load(bundle)
+
+    def test_refuses_empty_required_inventory(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle = Path(name) / "empty"; bundle.mkdir()
+            bundle.joinpath("manifest.json").write_text(
+                '{"format":"law.codegen-active-canaries/0.1","semanticVersion":"0.2.11","canaries":[],"unsupported":[]}'
+            )
+            with self.assertRaisesRegex(check_active_canaries.CanaryError, "required canary inventory"):
+                check_active_canaries.load(bundle)
+
+    def test_named_unsupported_copy_is_partial_only(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle, kit = self.bundle_and_kit(Path(name))
+            manifest_path = bundle / "manifest.json"
+            manifest = json.loads(manifest_path.read_text())
+            self.assertEqual([], manifest["unsupported"])
+            row = manifest["canaries"].pop()
+            shutil.rmtree(bundle / "canaries" / row["id"])
+            manifest["unsupported"] = [{"id": row["id"], "mutation": row["mutation"],
+                                        "reason": "synthetic unsupported target surface", "source": row["id"]}]
+            manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+            with self.assertRaisesRegex(check_active_canaries.CanaryError, "unsupported required"):
+                check_active_canaries.verify(bundle, core_kit=kit)
+            lines = check_active_canaries.verify(bundle, core_kit=kit, allow_partial=True)
+            self.assertTrue(lines[-1].startswith("PARTIAL unsupported required canaries: " + row["id"]))
+
+    def test_direct_cli_and_console_entry_are_wired(self) -> None:
+        with tempfile.TemporaryDirectory() as name:
+            bundle, kit = self.bundle_and_kit(Path(name))
+            command = [sys.executable, str(HERE / "check_active_canaries.py"), "--bundle", str(bundle),
+                       "--core-kit", str(kit)]
+            run = subprocess.run(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+            self.assertEqual(0, run.returncode, run.stderr)
+            self.assertIn("PASS LAY-L0-RAT-DYN-DECIMAL-KEPT", run.stdout)
+        project = (HERE / "pyproject.toml").read_text(encoding="utf-8")
+        self.assertIn('arxo-codegen-check-canaries = "arxo_codegen.check_active_canaries:main"', project)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_check_conformance.py

@@ -0,0 +1,132 @@
+"""The active registry (format 0.3) pins each vector by the digest of its own
+inputs: it must not hide missing coverage or regressions, and a change to one
+vector must not invalidate the pins of the others."""
+import copy
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import check_conformance as C
+
+
+def _manifest() -> dict:
+    return {"format": "law.codegen-fixtures/0.1",
+            "vectors": [{"id": "example", "path": "vectors/lay/example"},
+                        {"id": "other", "path": "vectors/lay/other"}],
+            "files": [{"path": "vectors/lay/example/ir.json", "sha256": "a", "bytes": 1, "source": "x"},
+                      {"path": "vectors/lay/other/ir.json", "sha256": "b", "bytes": 2, "source": "y"},
+                      {"path": "data/backends-vectors.json", "sha256": "c", "bytes": 3, "source": "z"}]}
+
+
+class RegistryTests(unittest.TestCase):
+    def setUp(self):
+        self.fixture = _manifest()
+        digests = C.vector_input_digests(self.fixture)
+        self.registry = {"format": C.REGISTRY_FORMAT,
+                         "semanticVersions": sorted(C.ACTIVE_SEMANTICS),
+                         "targets": ["py", "ts", "go"],
+                         "vectors": {"example": {"outcome": "match", "inputsSha256": digests["example"]}}}
+
+    def test_complete_registry(self):
+        C.validate_outcomes(self.registry, ("py", "ts", "go"))
+
+    def test_digest_is_per_vector_and_ignores_provenance(self):
+        before = C.vector_input_digests(self.fixture)
+        updated = copy.deepcopy(self.fixture)
+        updated["provenance"] = {"revision": "new source commit"}
+        updated["files"][0]["source"] = "different publisher cache"
+        updated["files"][1]["sha256"] = "changed"           # другой вектор
+        updated["files"][2]["sha256"] = "changed harness"   # не вектор
+        after = C.vector_input_digests(updated)
+        self.assertEqual(before["example"], after["example"])
+        self.assertNotEqual(before["other"], after["other"])
+
+    def test_regression_and_malformed_pins_are_rejected(self):
+        digest = self.registry["vectors"]["example"]["inputsSha256"]
+        for vectors in ({"example": {"outcome": "divergence", "inputsSha256": digest}},
+                        {"example": {"outcome": "crash", "inputsSha256": digest}},
+                        {"example": "match"},
+                        {"example": {"outcome": "match"}}):
+            with self.subTest(vectors=vectors), self.assertRaises(ValueError):
+                C.validate_outcomes(dict(self.registry, vectors=vectors), ("py",))
+
+    def test_scope_cannot_drift(self):
+        for key, value in (("format", "law.codegen-active-outcomes/0.2"),
+                           ("semanticVersions", ["0.1.1"]), ("targets", ["py"])):
+            with self.subTest(key=key), self.assertRaises(ValueError):
+                C.validate_outcomes(dict(self.registry, **{key: value}), ("py",))
+
+    def test_pin_outcome_reads_both_formats(self):
+        self.assertEqual(C.pin_outcome("match"), "match")
+        self.assertEqual(C.pin_outcome({"outcome": "plan: x", "inputsSha256": "sha256:0"}), "plan: x")
+        self.assertIsNone(C.pin_outcome(None))
+
+
+class VectorSelectionTests(unittest.TestCase):
+    def test_no_selector_keeps_the_full_inventory(self):
+        self.assertEqual(C.select_vectors({"A", "B"}), {"A", "B"})
+
+    def test_exact_ids_and_patterns_form_a_deduplicated_union(self):
+        self.assertEqual(C.select_vectors({"INST-A", "INST-B", "OTHER"},
+                                         ("OTHER", "INST-A"), ("INST-*",)),
+                         {"INST-A", "INST-B", "OTHER"})
+
+    def test_each_unknown_id_and_unmatched_pattern_is_an_error(self):
+        for ids, patterns in ((("TYPO",), ()), (("A",), ("MISSING*",)), (("",), ())):
+            with self.subTest(ids=ids, patterns=patterns), self.assertRaises(ValueError):
+                C.select_vectors({"A"}, ids, patterns)
+
+    def test_inertness_selection_adds_only_the_relevant_pair(self):
+        manifest = {"format": "test", "constructs": {
+            "node:a": {"witness": "A", "bare": "A-BARE"},
+            "node:b": {"witness": "B", "bare": "B-BARE"}}}
+        reduced, selected = C.selected_inert_witnesses(manifest, {"A-BARE", "OTHER"})
+        self.assertEqual(selected, {"A", "A-BARE", "OTHER"})
+        self.assertEqual(set(reduced["constructs"]), {"node:a"})
+        self.assertEqual(len(manifest["constructs"]), 2)
+
+
+@unittest.skipUnless(os.environ.get("LAW_CODEGEN_TEST_FIXTURES") and
+                     os.environ.get("LAW_CODEGEN_TEST_CORE_KIT"), "requires exported current inputs")
+class SelectedConformanceTests(unittest.TestCase):
+    def test_partial_development_run_does_not_enforce_the_retired_legacy_baseline(self):
+        fixtures = Path(os.environ["LAW_CODEGEN_TEST_FIXTURES"])
+        core = Path(os.environ["LAW_CODEGEN_TEST_CORE_KIT"])
+        ident = "LAY-L0-INST-EQ-MOMENT"
+        gate = C.check.load_harness(fixtures)
+        with tempfile.TemporaryDirectory(prefix="selected-legacy-baseline-") as tmp:
+            path = Path(tmp) / "legacy.json"
+            path.write_text(json.dumps({"format": gate.MANIFEST_FORMAT,
+                                        "vectors": {ident: "plan: retired release refusal"}}))
+            gate.MANIFEST = path
+            with patch.object(C.check, "load_harness", return_value=gate):
+                report, status = C.run(fixtures, core, timeout=10, targets=("py",), vectors=(ident,))
+        self.assertEqual(report["summary"]["outcomes"], {"match": 1})
+        self.assertEqual(report["summary"]["legacyMismatches"], [ident])
+        self.assertEqual(status, 0)
+
+    def test_partial_run_still_rejects_a_stale_explicit_pin(self):
+        fixtures = Path(os.environ["LAW_CODEGEN_TEST_FIXTURES"])
+        core = Path(os.environ["LAW_CODEGEN_TEST_CORE_KIT"])
+        ident = "LAY-L0-INST-EQ-MOMENT"
+        registry = {"format": C.REGISTRY_FORMAT, "semanticVersions": ["0.2.11"],
+                    "targets": ["py", "ts", "go"], "vectors": {
+                        ident: {"outcome": "match", "inputsSha256": "sha256:" + "0" * 64}}}
+        with tempfile.TemporaryDirectory(prefix="selected-stale-pin-") as tmp:
+            path = Path(tmp) / "outcomes.json"
+            path.write_text(json.dumps(registry))
+            report, status = C.run(fixtures, core, timeout=10, targets=("py",),
+                                   outcomes=path, vectors=(ident,))
+        self.assertEqual(report["summary"]["outcomes"], {"match": 1})
+        self.assertEqual(report["scope"]["mode"], "partial")
+        self.assertEqual(report["summary"]["stalePins"], [ident])
+        self.assertEqual(status, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_check_semantic_probes.py

@@ -0,0 +1,85 @@
+"""Portable verification tests for the published semantic-probe bundle."""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+HERE = Path(__file__).resolve().parent
+import sys
+if str(HERE) not in sys.path:
+    sys.path.insert(0, str(HERE))
+
+import check_semantic_probes as C
+import test_support as S
+
+
+class SemanticProbeTests(unittest.TestCase):
+    def _bundle(self, root: Path) -> Path:
+        return S.materialize_semantic_probes(root / "semantic")
+
+    @staticmethod
+    def _rewrite_hash(bundle: Path, ident: str, name: str) -> None:
+        manifest_path = bundle / "manifest.json"
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        row = next(row for row in manifest["probes"] if row["id"] == ident)
+        data = (bundle / "probes" / ident / name).read_bytes()
+        row["files"][name] = "sha256:" + hashlib.sha256(data).hexdigest()
+        manifest_path.write_text(json.dumps(manifest, ensure_ascii=False), encoding="utf-8")
+
+    def test_bundle_executes_with_exported_core_kit(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            bundle = self._bundle(root)
+            kit = S.materialize_core_kit(root / "core", source_commit="3" * 40)
+            self.assertEqual(8, len(C.verify(bundle, root / "core")))
+            self.assertEqual("law.codegen-core-kit/0.1", kit["format"])
+
+    def test_targets_require_unique_available_runner_descriptors(self) -> None:
+        with patch.object(C.D, "targets", return_value=["py", "ts"]), \
+             patch.object(C.D, "emitter") as emitter:
+            emitter.return_value.available.return_value = (True, "available")
+            self.assertEqual(("py", "ts"), C._targets(("py", "ts")))
+            with self.assertRaisesRegex(C.CanaryError, "unique known"):
+                C._targets(("py", "py"))
+            emitter.return_value.available.return_value = (False, "not installed")
+            with self.assertRaisesRegex(C.CanaryError, "unavailable"):
+                C._targets(("py",))
+
+    def test_duplicate_id_is_rejected(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            bundle = self._bundle(Path(temporary))
+            manifest_path = bundle / "manifest.json"
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            manifest["probes"][-1]["id"] = manifest["probes"][0]["id"]
+            manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+            with self.assertRaisesRegex(C.CanaryError, "duplicate"):
+                C.load(bundle)
+
+    def test_symlink_escape_is_rejected(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            bundle = self._bundle(Path(temporary))
+            outside = Path(temporary) / "outside.json"
+            outside.write_text("{}", encoding="utf-8")
+            link = bundle / "probes" / "i64-max" / "escape.json"
+            link.symlink_to(outside)
+            with self.assertRaisesRegex(C.CanaryError, "symlink"):
+                C.load(bundle)
+
+    def test_rehashed_i64_mutation_is_rejected_by_contract(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            bundle = self._bundle(Path(temporary))
+            query_path = bundle / "probes" / "i64-max" / "query.json"
+            query = json.loads(query_path.read_text(encoding="utf-8"))
+            query["term"]["value"] = 1
+            query_path.write_text(json.dumps(query), encoding="utf-8")
+            self._rewrite_hash(bundle, "i64-max", "query.json")
+            with self.assertRaisesRegex(C.CanaryError, "canonical number"):
+                C.load(bundle)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_check_xlsx.py

@@ -0,0 +1,52 @@
+import sys
+import tempfile
+import unittest
+from decimal import Decimal
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import check_xlsx
+from test_support import materialize_core_kit, materialize_xlsx
+
+
+class CheckXlsxTests(unittest.TestCase):
+    def fixture(self, base: Path) -> Path:
+        out = base / "fixtures"; return materialize_xlsx(out)
+
+    def test_accepts_exported_active_fixture_without_oracle_import(self):
+        with tempfile.TemporaryDirectory() as name:
+            fixture = self.fixture(Path(name))
+            _, expected = check_xlsx.load(fixture)
+            check_xlsx.structural(fixture, expected)
+
+    def test_refuses_tampered_export(self):
+        with tempfile.TemporaryDirectory() as name:
+            fixture = self.fixture(Path(name))
+            model = fixture / "pricing/program.lawir.json"
+            model.write_bytes(model.read_bytes() + b"tampered")
+            with self.assertRaisesRegex(check_xlsx.FixtureError, "hash"):
+                check_xlsx.load(fixture)
+
+    def test_regenerates_with_explicit_core_kit_and_empty_resources(self):
+        with tempfile.TemporaryDirectory() as name:
+            base = Path(name); fixture = self.fixture(base)
+            core = base / "core"; materialize_core_kit(core, source_commit="1" * 40)
+            _, expected = check_xlsx.load(fixture)
+            regenerated = base / "regenerated"
+            check_xlsx.regenerate(fixture, expected, core, regenerated)
+            self.assertTrue((regenerated / "pricing/program.lawir.json").is_file())
+            self.assertFalse((regenerated / "pricing/model.xlsx").exists())
+
+    def test_math_mutation_preserves_numeric_cell_type(self):
+        with tempfile.TemporaryDirectory() as name:
+            fixture = self.fixture(Path(name))
+            mapping = {"inputs": {"urn:law:example:excel#operands": [{"args": ["Inputs!A1", "Inputs!B1"]}]}}
+            values = check_xlsx.changes_for("arithmetic", {"changes": {"operands": ["1.25", "2"]}}, mapping,
+                                             "urn:law:example:excel#")
+            self.assertEqual(set(values.values()), {Decimal("1.25"), Decimal("2")})
+
+
+if __name__ == "__main__":
+    unittest.main()