lean-runtime 3.0.2__tar.gz → 3.0.3__tar.gz

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 3.0.3 - 2026-08-18
+
+- Give sparse-environment and slim-toolchain downloads independent progress
+  lifecycles, so the toolchain transfer reports its real size instead of
+  inheriting a completed environment total.
+- Reject duplicate members and symlink extraction destinations in
+  slim-toolchain archives, matching the portable-environment boundary.
+- Correct the announcement gate's versioned plan-envelope parsing and add the
+  missing macOS Intel clean-consumer job.
+- Expand release acceptance coverage for archive limits and traversal,
+  deterministic multi-platform finalization, duplicate platforms, supported
+  Cosign releases, missing Cosign, and publisher identity/issuer mismatches.
+
 ## 3.0.2 - 2026-08-17
 
 - Route the first check directly through a newly downloaded slim Lean runtime.

{lean_runtime-3.0.2/lean_runtime.egg-info → lean_runtime-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 3.0.2
+Version: 3.0.3
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/lean_runtime/console.py

@@ -129,6 +129,16 @@ class ConsoleRenderer:
         cached = event.data.get("cached_bytes")
         if not isinstance(download, int) or download <= 0:
             return
+        self._start_download("Downloading environment", download, cached)
+
+    def _render_toolchain_download_planned(self, event: RuntimeEvent) -> None:
+        download = event.data.get("download_bytes")
+        cached = event.data.get("cached_bytes")
+        if not isinstance(download, int) or download <= 0:
+            return
+        self._start_download("Downloading Lean toolchain", download, cached)
+
+    def _start_download(self, label: str, download: int, cached: object) -> None:
         self._download_total = download
         self._layer_bytes.clear()
         self._next_checkpoint = _PLAIN_CHECKPOINT_PERCENT
@@ -139,11 +149,11 @@ class ConsoleRenderer:
             if isinstance(cached, int) and cached > 0
             else ""
         )
-        self._print(f"Downloading environment: {format_byte_size(download)}{suffix}")
+        self._print(f"{label}: {format_byte_size(download)}{suffix}")
 
     def _render_library_layer_progress(self, event: RuntimeEvent) -> None:
         digest = str(event.data.get("digest", ""))
-        if event.current_bytes is None or self._download_total is None:
+        if event.current_bytes is None or self._download_total is None or self._download_finished:
             return
         frame_current = event.data.get("frame_current")
         frame_total = event.data.get("frame_total")
@@ -181,13 +191,19 @@ class ConsoleRenderer:
         self._print("Retrying download after integrity verification failed")
 
     def _render_library_verified(self, event: RuntimeEvent) -> None:
+        self._finish_download("Downloaded and verified environment")
+
+    def _render_toolchain_ready(self, event: RuntimeEvent) -> None:
+        self._finish_download("Downloaded and verified Lean toolchain")
+
+    def _finish_download(self, message: str) -> None:
         if self._download_total is None or self._download_finished:
             return
         self._download_finished = True
         if self.mode == "tty":
             self._draw_bar(self._download_total, self._download_total)
         self._end_progress_line()
-        self._print(self.style.green("Downloaded and verified environment"))
+        self._print(self.style.green(message))
 
     def _render_source_fetch_started(self, event: RuntimeEvent) -> None:
         package = event.data.get("package", "sources")

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/lean_runtime/toolchain_oci.py

@@ -44,6 +44,7 @@ from .oci_protocol import (
 from .oci_protocol import (
     platform_matches as _platform_matches,
 )
+from .policies import format_byte_size
 from .serialization import canonical_json_bytes
 from .store import EnvironmentStore, platform_compatibility
 from .toolchain_slim import SlimManifest, materialize, verify_capabilities
@@ -120,6 +121,9 @@ def _safe_member(name: str) -> PurePosixPath:
 
 def _extract_layer(layer: Path, destination: Path) -> None:
     total = count = 0
+    seen: set[PurePosixPath] = set()
+    if destination.is_symlink():
+        raise ToolchainError("check toolchain extraction destination must not be a symlink")
     try:
         with (
             layer.open("rb") as raw,
@@ -132,6 +136,9 @@ def _extract_layer(layer: Path, destination: Path) -> None:
                 if count > MAX_TOOLCHAIN_FILES or total > MAX_TOOLCHAIN_BYTES:
                     raise ToolchainError("check toolchain exceeds extraction limits")
                 relative = _safe_member(member.name)
+                if relative in seen:
+                    raise ToolchainError(f"duplicate check toolchain member: {member.name!r}")
+                seen.add(relative)
                 target = destination.joinpath(*relative.parts)
                 for parent in target.parents:
                     if parent == destination:
@@ -147,6 +154,8 @@ def _extract_layer(layer: Path, destination: Path) -> None:
                     target.chmod(member.mode & 0o777)
                 elif member.isfile():
                     target.parent.mkdir(parents=True, exist_ok=True)
+                    if target.exists() or target.is_symlink():
+                        raise ToolchainError(f"duplicate check toolchain member: {member.name!r}")
                     source = archive.extractfile(member)
                     if source is None:
                         raise ToolchainError("check toolchain file has no payload")
@@ -166,6 +175,8 @@ def _extract_layer(layer: Path, destination: Path) -> None:
                     ):
                         raise ToolchainError("check toolchain contains an unsafe symlink")
                     target.parent.mkdir(parents=True, exist_ok=True)
+                    if target.exists() or target.is_symlink():
+                        raise ToolchainError(f"duplicate check toolchain member: {member.name!r}")
                     target.symlink_to(linkname)
                 else:
                     raise ToolchainError(
@@ -325,6 +336,15 @@ class OCIToolchainLibrary:
         if callable(local_check) and local_check(toolchain):
             return True
         plan = self.plan(toolchain)
+        if plan.download_bytes:
+            self.events.emit(
+                "toolchain.download_planned",
+                f"Check toolchain download planned: {format_byte_size(plan.download_bytes)}",
+                phase="acquisition",
+                toolchain=plan.toolchain,
+                download_bytes=plan.download_bytes,
+                cached_bytes=plan.cached_bytes,
+            )
         self.client.cache_verified_blob(plan.config_data, plan.config_descriptor, self.store)
         try:
             layer = self.client.download_blob(
@@ -346,6 +366,12 @@ class OCIToolchainLibrary:
             cancel=cancel,
         ):
             if self.toolchains.is_available_locally(toolchain):
+                self.events.emit(
+                    "toolchain.ready",
+                    "Lean check toolchain is ready",
+                    phase="acquisition",
+                    toolchain=plan.toolchain,
+                )
                 return True
             staging = destination.parent / f".{destination.name}.staging-{os.getpid()}"
             if staging.exists():
@@ -381,6 +407,12 @@ class OCIToolchainLibrary:
             finally:
                 if staging.exists():
                     shutil.rmtree(staging)
+        self.events.emit(
+            "toolchain.ready",
+            "Lean check toolchain is ready",
+            phase="acquisition",
+            toolchain=plan.toolchain,
+        )
         return True
 
 

{lean_runtime-3.0.2 → lean_runtime-3.0.3/lean_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 3.0.2
+Version: 3.0.3
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/lean_runtime.egg-info/SOURCES.txt

@@ -136,6 +136,7 @@ scripts/run_compatibility.py
 scripts/run_v1_case_study.py
 scripts/smoke_wheel.py
 tests/conftest.py
+tests/test_announcement_gate.py
 tests/test_backend.py
 tests/test_bundles.py
 tests/test_capsules.py

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lean-runtime"
-version = "3.0.2"
+version = "3.0.3"
 description = "Run Lean 4 proofs from Python or standalone files"
 readme = "README.md"
 requires-python = ">=3.10"

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/scripts/announcement_gate.py

@@ -43,6 +43,20 @@ FULL_INCREMENTAL_LIMIT = 2 * 1024**3
 HOME_LIMIT = 9 * 1024**3
 
 
+def plan_data(value: object) -> dict[str, object]:
+    """Return data from a successful, versioned plan envelope."""
+    if not isinstance(value, dict):
+        return {}
+    data = value.get("data")
+    if (
+        value.get("schema") != "lean-runtime.plan/v1"
+        or value.get("ok") is not True
+        or not isinstance(data, dict)
+    ):
+        return {}
+    return data
+
+
 def run(
     command: list[str],
     *,
@@ -148,9 +162,8 @@ def main() -> int:
             value = json.loads(output)
         except json.JSONDecodeError:
             value = {}
-        ok = code == 0 and isinstance(value, dict)
-        if ok:
-            ok = bool(value.get("download_bytes_complete"))
+        data = plan_data(value)
+        ok = code == 0 and data.get("download_bytes_complete") is True
         steps.append(
             {
                 "name": name,
@@ -164,7 +177,7 @@ def main() -> int:
             }
         )
         print(f"{'ok  ' if ok else 'FAIL'} {name} ({elapsed:.1f}s)")
-        return ok, value
+        return ok, data
 
     ok, narrow_plan = plan("narrow-plan", narrow_lean)
     narrow_environment = narrow_plan.get("environment_download_bytes")

lean_runtime-3.0.3/tests/test_announcement_gate.py

@@ -0,0 +1,43 @@
+from collections.abc import Callable
+from pathlib import Path
+from runpy import run_path
+from typing import cast
+
+plan_data = cast(
+    Callable[[object], dict[str, object]],
+    run_path(str(Path(__file__).parents[1] / "scripts" / "announcement_gate.py"))["plan_data"],
+)
+
+
+def test_announcement_gate_reads_budget_fields_from_plan_envelope() -> None:
+    assert plan_data(
+        {
+            "schema": "lean-runtime.plan/v1",
+            "ok": True,
+            "errors": [],
+            "warnings": [],
+            "data": {
+                "download_bytes": 200,
+                "environment_download_bytes": 100,
+                "download_bytes_complete": True,
+            },
+        }
+    ) == {
+        "download_bytes": 200,
+        "environment_download_bytes": 100,
+        "download_bytes_complete": True,
+    }
+
+
+def test_announcement_gate_rejects_failed_or_unversioned_plan_envelopes() -> None:
+    assert plan_data({"ok": True, "data": {"download_bytes_complete": True}}) == {}
+    assert (
+        plan_data(
+            {
+                "schema": "lean-runtime.plan/v1",
+                "ok": False,
+                "data": {"download_bytes_complete": True},
+            }
+        )
+        == {}
+    )

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/tests/test_bundles.py

@@ -157,11 +157,15 @@ def _layer(*members: tuple[str, str, bytes | str]) -> bytes:
                 assert isinstance(value, bytes)
                 info.size = len(value)
                 archive.addfile(info, io.BytesIO(value))
-            else:
-                assert kind == "symlink" and isinstance(value, str)
+            elif kind == "symlink":
+                assert isinstance(value, str)
                 info.type = tarfile.SYMTYPE
                 info.linkname = value
                 archive.addfile(info)
+            else:
+                assert kind == "fifo"
+                info.type = tarfile.FIFOTYPE
+                archive.addfile(info)
     return output.getvalue()
 
 
@@ -198,6 +202,42 @@ def test_layer_extract_rejects_later_write_through_symlink(tmp_path: Path) -> No
         _extract_layer(layer, tmp_path / "output")
 
 
+@pytest.mark.parametrize("name", ["/absolute", "../escape", "dir/../../escape", "dir\\escape"])
+def test_layer_extract_rejects_unsafe_paths(tmp_path: Path, name: str) -> None:
+    with pytest.raises(EnvironmentError, match="unsafe bundle member path"):
+        _extract_layer(_layer(("file", name, b"payload")), tmp_path / "output")
+
+
+def test_layer_extract_rejects_duplicate_member(tmp_path: Path) -> None:
+    layer = _layer(
+        ("file", "payload", b"first"),
+        ("file", "payload", b"replacement"),
+    )
+    with pytest.raises(EnvironmentError, match="duplicate bundle member"):
+        _extract_layer(layer, tmp_path / "output")
+
+
+def test_layer_extract_rejects_special_member(tmp_path: Path) -> None:
+    with pytest.raises(EnvironmentError, match="unsupported bundle member"):
+        _extract_layer(_layer(("fifo", "pipe", b"")), tmp_path / "output")
+
+
+def test_layer_extract_rejects_limits(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("lean_runtime.bundles.MAX_BUNDLE_BYTES", 1)
+    with pytest.raises(EnvironmentError, match="exceeds extraction limits"):
+        _extract_layer(_layer(("file", "large", b"ab")), tmp_path / "output")
+
+
+@pytest.mark.skipif(os.name == "nt", reason="Windows runners may not permit symlink creation")
+def test_layer_extract_rejects_symlink_destination(tmp_path: Path) -> None:
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    destination = tmp_path / "destination"
+    destination.symlink_to(outside, target_is_directory=True)
+    with pytest.raises(EnvironmentError, match="destination must not be a symlink"):
+        _extract_layer(_layer(("file", "payload", b"payload")), destination)
+
+
 def test_bundle_export_is_deterministic_and_imports_into_fresh_store(tmp_path: Path) -> None:
     producer, environment_id, lock = _published_runtime(tmp_path / "producer")
     first = tmp_path / "first.oci.tar.gz"
@@ -1098,6 +1138,58 @@ def test_oci_publisher_reports_partial_state_when_tag_finalization_fails(
     assert not any(event.kind == "library.published" for event in events)
 
 
+def test_environment_index_finalization_is_ordered_and_rejects_duplicate_platforms(
+    tmp_path: Path,
+) -> None:
+    producer, _environment_id, lock = _published_runtime(tmp_path / "producer")
+    publisher = OCIEnvironmentPublisher(
+        OCIRepository.parse("oci://registry.example/owner/cache"),
+        producer.store,
+        producer.bundles,
+        EventEmitter(),
+    )
+    published: list[tuple[str, bytes]] = []
+
+    class IndexClient:
+        def check_push_access(self) -> None:
+            pass
+
+        def manifest_exists(self, _digest: str) -> bool:
+            return True
+
+        def publish_manifest(self, reference: str, data: bytes, _media_type: str) -> str:
+            published.append((reference, data))
+            return "sha256:" + hashlib.sha256(data).hexdigest()
+
+    publisher.client = IndexClient()  # type: ignore[assignment]
+
+    def descriptor(system: str, architecture: str, abi: str, digest: str) -> dict[str, object]:
+        return {
+            "mediaType": "application/vnd.oci.image.manifest.v1+json",
+            "digest": "sha256:" + digest * 64,
+            "size": 42,
+            "platform": {"os": system, "architecture": architecture},
+            "annotations": {"org.lean-runtime.platform.abi": abi},
+        }
+
+    linux = descriptor("linux", "amd64", "glibc-2.35", "a")
+    macos = descriptor("darwin", "arm64", "darwin-arm64", "b")
+    publication_id = publisher.publish_index(lock.lock_id, [linux, macos], tags=("dogfood",))
+
+    assert publication_id.startswith("sha256:")
+    assert [reference for reference, _data in published] == [
+        "capsule-" + lock.lock_id,
+        "dogfood",
+    ]
+    assert published[0][1] == published[1][1]
+    index = json.loads(published[0][1])
+    assert [item["platform"]["os"] for item in index["manifests"]] == ["darwin", "linux"]
+
+    duplicate = descriptor("linux", "amd64", "glibc-2.35", "c")
+    with pytest.raises(ValueError, match="duplicate OCI platform result"):
+        publisher.publish_index(lock.lock_id, [linux, duplicate])
+
+
 def test_oci_truncated_blob_download_resumes_with_range(tmp_path: Path) -> None:
     data = b"large layer contents " * 512
     cut = len(data) // 3

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/tests/test_console.py

@@ -112,6 +112,42 @@ def test_plan_with_nothing_to_download_is_silent() -> None:
     assert stream.getvalue() == ""
 
 
+def test_toolchain_download_starts_a_new_progress_lifecycle() -> None:
+    renderer, stream = _renderer("plain")
+    renderer(_event("acquisition.planned", download_bytes=100, cached_bytes=0))
+    renderer(_event("library.layer_progress", digest="sha256:environment", current_bytes=100))
+    renderer(_event("library.verified", "done"))
+
+    # Progress emitted between completed acquisitions must not be folded into
+    # the environment total. The toolchain plan establishes its own aggregate.
+    renderer(_event("library.layer_progress", digest="sha256:late", current_bytes=10_000))
+    renderer(
+        _event(
+            "toolchain.download_planned",
+            download_bytes=1000,
+            cached_bytes=25,
+        )
+    )
+    renderer(_event("library.layer_progress", digest="sha256:toolchain", current_bytes=500))
+    renderer(_event("library.layer_progress", digest="sha256:toolchain", current_bytes=1000))
+    renderer(_event("toolchain.ready", "done"))
+
+    assert stream.getvalue().splitlines() == [
+        "Downloading environment: 100 B",
+        "Downloaded 25%",
+        "Downloaded 50%",
+        "Downloaded 75%",
+        "Downloaded 100%",
+        "Downloaded and verified environment",
+        "Downloading Lean toolchain: 1000 B (25 B already cached)",
+        "Downloaded 25%",
+        "Downloaded 50%",
+        "Downloaded 75%",
+        "Downloaded 100%",
+        "Downloaded and verified Lean toolchain",
+    ]
+
+
 def test_tty_mode_redraws_one_line_and_finishes_it() -> None:
     time = [0.0]
     renderer, stream = _renderer("tty", clock=lambda: time[0])

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/tests/test_programs.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import os
 from pathlib import Path
 
 import pytest
 
 from lean_runtime import EnvironmentError, ExecutionPolicy, Runtime
-from lean_runtime.programs import LEGACY_PROGRAM_SCHEMA, ProgramDescription
+from lean_runtime.oci import OCIRepository
+from lean_runtime.programs import LEGACY_PROGRAM_SCHEMA, ProgramDescription, ProgramLibrary
 
 
 def _revision() -> str:
@@ -111,6 +113,53 @@ def test_program_oci_round_trip_is_deterministic(tmp_path: Path) -> None:
     assert imported.copy_id == first_info.copy_id
 
 
+def test_program_index_finalization_is_ordered_and_rejects_duplicate_platforms() -> None:
+    library = ProgramLibrary(
+        OCIRepository.parse("oci://registry.example/owner/programs"),
+        None,  # type: ignore[arg-type]
+        None,  # type: ignore[arg-type]
+        None,  # type: ignore[arg-type]
+    )
+    published: list[tuple[str, bytes]] = []
+
+    class IndexClient:
+        def manifest_exists(self, _digest: str) -> bool:
+            return True
+
+        def publish_manifest(self, reference: str, data: bytes, _media_type: str) -> str:
+            published.append((reference, data))
+            return "sha256:" + hashlib.sha256(data).hexdigest()
+
+    library.client = IndexClient()  # type: ignore[assignment]
+
+    def descriptor(system: str, architecture: str, abi: str, digest: str) -> dict[str, object]:
+        return {
+            "mediaType": "application/vnd.oci.image.manifest.v1+json",
+            "digest": "sha256:" + digest * 64,
+            "size": 42,
+            "platform": {"os": system, "architecture": architecture},
+            "annotations": {
+                "org.lean-runtime.artifact.kind": "execution-program",
+                "org.lean-runtime.platform.abi": abi,
+            },
+        }
+
+    linux = descriptor("linux", "amd64", "glibc-2.35", "a")
+    macos = descriptor("darwin", "arm64", "darwin-arm64", "b")
+    revision = "c" * 40
+    publication_id = library.publish_index(revision, [linux, macos], tags=("dogfood",))
+
+    assert publication_id.startswith("sha256:")
+    assert [reference for reference, _data in published] == [revision, "dogfood"]
+    assert published[0][1] == published[1][1]
+    index = json.loads(published[0][1])
+    assert [item["platform"]["os"] for item in index["manifests"]] == ["darwin", "linux"]
+
+    duplicate = descriptor("linux", "amd64", "glibc-2.35", "d")
+    with pytest.raises(ValueError, match="duplicate program platform"):
+        library.publish_index(revision, [linux, duplicate])
+
+
 def test_program_rejects_command_outside_payload(tmp_path: Path) -> None:
     runtime = Runtime(home=tmp_path / "runtime")
     with pytest.raises(EnvironmentError, match="absent"):

{lean_runtime-3.0.2 → lean_runtime-3.0.3}/tests/test_signatures.py

@@ -51,6 +51,56 @@ def test_vulnerable_cosign_release_is_rejected(
         CosignVerifier("identity", "issuer", executable=executable)
 
 
+@pytest.mark.parametrize("version", ["v2.6.2", "v2.99.0", "v3.0.4", "v3.9.0"])
+def test_supported_cosign_releases_are_accepted(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, version: str
+) -> None:
+    executable = tmp_path / "verification_tool"
+    executable.write_text("")
+    monkeypatch.setattr(
+        "lean_runtime.publisher_verification.subprocess.run",
+        lambda *_args, **_kwargs: SimpleNamespace(
+            returncode=0, stdout=f'{{"gitVersion":"{version}"}}', stderr=""
+        ),
+    )
+    CosignVerifier("identity", "issuer", executable=executable)
+
+
+def test_missing_cosign_is_rejected(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("lean_runtime.publisher_verification.shutil.which", lambda _name: None)
+    with pytest.raises(EnvironmentError, match="required.*not installed"):
+        CosignVerifier("identity", "issuer", executable="definitely-missing-cosign")
+
+
+def test_publisher_identity_and_issuer_must_be_configured_together() -> None:
+    with pytest.raises(ValueError, match="both identity and OIDC issuer"):
+        CosignVerifier("identity", None)
+    with pytest.raises(ValueError, match="both identity and OIDC issuer"):
+        CosignVerifier(None, "issuer")
+
+
+def test_wrong_publisher_identity_or_issuer_is_an_integrity_failure(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    executable = tmp_path / "verification_tool"
+    executable.write_text("")
+
+    def run(command: list[str], **_kwargs: object) -> SimpleNamespace:
+        if command[1:3] == ["version", "--json"]:
+            return SimpleNamespace(returncode=0, stdout='{"gitVersion":"v3.0.4"}', stderr="")
+        assert command[1] == "verify"
+        return SimpleNamespace(
+            returncode=1,
+            stdout="",
+            stderr="no matching signatures: certificate identity or issuer mismatch",
+        )
+
+    monkeypatch.setattr("lean_runtime.publisher_verification.subprocess.run", run)
+    verifier = CosignVerifier("wrong-identity", "wrong-issuer", executable=executable)
+    with pytest.raises(EnvironmentError, match="signature verification failed.*identity or issuer"):
+        verifier.verify(OCIRepository.parse("oci://ghcr.io/owner/cache"), "sha256:" + "a" * 64)
+
+
 def test_cosign_attestation_binds_predicate_to_digest(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None: