lean-runtime 2.1.2__tar.gz → 2.2.0__tar.gz

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.2.0 - 2026-08-12
+
+- Make published-environment checks invoke Lean directly with the immutable
+  compiled module roots instead of cloning the multi-gigabyte workspace and
+  asking Lake to rescan its full build graph on every proof. Multi-file checks
+  compile support modules into the disposable scratch tree; build and execute
+  operations keep their existing isolated workspace clones.
+- Resolve exact bundled references such as `mathlib@v4.32.2` to the catalog's
+  downloadable lock before Git/Lake resolution. The Python setup API,
+  `lean-run --with`, frontmatter, and `--lock-out` now share the same lock and
+  reuse the same environment rather than creating a duplicate cache entry.
+
 ## 2.1.2 - 2026-08-12
 
 - Raise `lean-run`'s default `--check-timeout` from 120 to 300 seconds: a

{lean_runtime-2.1.2/lean_runtime.egg-info → lean_runtime-2.2.0}/PKG-INFO

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

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/lean_runtime/environments.py

@@ -147,6 +147,32 @@ def _package_import_targets(files: Mapping[str, str], lock: EnvironmentLock) ->
     return tuple(sorted(targets))
 
 
+def _check_lean_paths(workspace: Path, scratch: Path, lock: EnvironmentLock) -> tuple[Path, ...]:
+    """Return the compiled module roots for a check without asking Lake to scan them."""
+    roots = [scratch / ".lake" / "build" / "lib" / "lean"]
+    workspace_root = workspace / ".lake" / "build" / "lib" / "lean"
+
+    raw_packages_dir = lock.manifest.get("packagesDir", ".lake/packages")
+    if not isinstance(raw_packages_dir, str):
+        raise EnvironmentError("lock packagesDir must be a relative string")
+    packages_dir = PurePosixPath(raw_packages_dir)
+    if packages_dir.is_absolute() or ".." in packages_dir.parts:
+        raise EnvironmentError("lock packagesDir must be a safe relative path")
+    package_root = workspace.joinpath(*packages_dir.parts)
+    for package in lock.packages:
+        root = package_root / package.name
+        if package.subdir:
+            root = root.joinpath(*PurePosixPath(package.subdir).parts)
+        compiled = root / ".lake" / "build" / "lib" / "lean"
+        if compiled.is_dir():
+            roots.append(compiled)
+    # Lake places dependencies before the root package. Keep that precedence;
+    # the scratch root remains first so submitted support modules win.
+    if workspace_root.is_dir():
+        roots.append(workspace_root)
+    return tuple(roots)
+
+
 @dataclass(frozen=True, slots=True)
 class EnvironmentInfo:
     environment_id: str
@@ -755,125 +781,96 @@ class Environment:
         try:
             instance_started = time.monotonic()
             with self.manager.store.execution_lease(self.id):
-                clone_tree(self.workspace, instance)
-            instance_timing = PhaseTiming(
-                "instance_creation", round((time.monotonic() - instance_started) * 1000)
-            )
-            preliminary: list[BackendResult] = []
-            path_map = {str(instance / name): name for name in files}
-            staging_started = time.monotonic()
-            if operation == "check":
-                assert entrypoint is not None
-                for name, source in files.items():
-                    source_path = instance / name
-                    source_path.parent.mkdir(parents=True, exist_ok=True)
-                    source_path.write_text(source, encoding="utf-8")
-                staging_timing = PhaseTiming(
-                    "input_staging", round((time.monotonic() - staging_started) * 1000)
+                if operation == "check":
+                    instance.mkdir()
+                else:
+                    clone_tree(self.workspace, instance)
+                instance_timing = PhaseTiming(
+                    "instance_creation", round((time.monotonic() - instance_started) * 1000)
                 )
-                import_targets = _package_import_targets(files, self.lock)
-                if import_targets:
-                    import_command = self.manager.toolchains.command(
-                        self.lock.toolchain, "lake", "build", *import_targets
+                preliminary: list[BackendResult] = []
+                path_map = {str(instance / name): name for name in files}
+                staging_started = time.monotonic()
+                execution_environment = self.manager.toolchains.environment
+                if operation == "check":
+                    assert entrypoint is not None
+                    for name, source in files.items():
+                        source_path = instance / name
+                        source_path.parent.mkdir(parents=True, exist_ok=True)
+                        source_path.write_text(source, encoding="utf-8")
+                    staging_timing = PhaseTiming(
+                        "input_staging", round((time.monotonic() - staging_started) * 1000)
                     )
-                    import_result = self.manager.backend.execute(
-                        import_command,
-                        cwd=instance,
-                        environment=self.manager.toolchains.environment,
-                        policy=policy,
-                        cancel=cancel,
+                    lean_paths = _check_lean_paths(self.workspace, instance, self.lock)
+                    execution_environment["LEAN_PATH"] = os.pathsep.join(
+                        str(path) for path in lean_paths
                     )
-                    preliminary.append(import_result)
-                    if import_result.exit_code:
-                        result = self._result(
-                            import_result,
-                            command=import_command,
+                    for support in _support_order(files, entrypoint):
+                        support_path = instance / support
+                        output_path = (
+                            instance / ".lake" / "build" / "lib" / "lean" / support
+                        ).with_suffix(".olean")
+                        output_path.parent.mkdir(parents=True, exist_ok=True)
+                        support_command = self.manager.toolchains.command(
+                            self.lock.toolchain,
+                            "lean",
+                            "-R",
+                            str(instance),
+                            "-o",
+                            str(output_path),
+                            str(support_path),
+                        )
+                        support_result = self.manager.backend.execute(
+                            support_command,
                             cwd=instance,
-                            execution_id=execution_id,
-                            request_digest=request_digest,
-                            source_digest=source_digest,
-                            started_at=started_at,
+                            environment=execution_environment,
                             policy=policy,
-                            timings=(instance_timing, staging_timing),
-                            path_map=path_map,
-                        )
-                        self._record_execution(
-                            result,
-                            operation,
-                            targets,
-                            entrypoint,
-                            tuple(files),
-                            requested_command,
+                            cancel=cancel,
                         )
-                        return result
-                for support in _support_order(files, entrypoint):
-                    support_path = instance / support
-                    output_path = (
-                        instance / ".lake" / "build" / "lib" / "lean" / support
-                    ).with_suffix(".olean")
-                    output_path.parent.mkdir(parents=True, exist_ok=True)
-                    support_command = self.manager.toolchains.command(
-                        self.lock.toolchain,
-                        "lake",
-                        "env",
-                        "lean",
-                        "-R",
-                        str(instance),
-                        "-o",
-                        str(output_path),
-                        str(support_path),
+                        preliminary.append(support_result)
+                        if support_result.exit_code:
+                            result = self._result(
+                                support_result,
+                                command=support_command,
+                                cwd=instance,
+                                execution_id=execution_id,
+                                request_digest=request_digest,
+                                source_digest=source_digest,
+                                started_at=started_at,
+                                policy=policy,
+                                timings=(instance_timing, staging_timing),
+                                path_map=path_map,
+                            )
+                            self._record_execution(
+                                result,
+                                operation,
+                                targets,
+                                entrypoint,
+                                tuple(files),
+                                requested_command,
+                            )
+                            return result
+                    source_path = instance / entrypoint
+                    command = self.manager.toolchains.command(
+                        self.lock.toolchain, "lean", "-R", str(instance), str(source_path)
                     )
-                    support_result = self.manager.backend.execute(
-                        support_command,
-                        cwd=instance,
-                        environment=self.manager.toolchains.environment,
-                        policy=policy,
-                        cancel=cancel,
+                elif operation == "build":
+                    staging_timing = PhaseTiming("input_staging", 0, performed=False)
+                    command = self.manager.toolchains.command(
+                        self.lock.toolchain, "lake", "build", *targets
                     )
-                    preliminary.append(support_result)
-                    if support_result.exit_code:
-                        result = self._result(
-                            support_result,
-                            command=support_command,
-                            cwd=instance,
-                            execution_id=execution_id,
-                            request_digest=request_digest,
-                            source_digest=source_digest,
-                            started_at=started_at,
-                            policy=policy,
-                            timings=(instance_timing, staging_timing),
-                            path_map=path_map,
-                        )
-                        self._record_execution(
-                            result,
-                            operation,
-                            targets,
-                            entrypoint,
-                            tuple(files),
-                            requested_command,
-                        )
-                        return result
-                source_path = instance / entrypoint
-                command = self.manager.toolchains.command(
-                    self.lock.toolchain, "lake", "env", "lean", str(source_path)
-                )
-            elif operation == "build":
-                staging_timing = PhaseTiming("input_staging", 0, performed=False)
-                command = self.manager.toolchains.command(
-                    self.lock.toolchain, "lake", "build", *targets
-                )
-            else:
-                staging_timing = PhaseTiming("input_staging", 0, performed=False)
-                command = self.manager.toolchains.command(
-                    self.lock.toolchain, requested_command[0], *requested_command[1:]
+                else:
+                    staging_timing = PhaseTiming("input_staging", 0, performed=False)
+                    command = self.manager.toolchains.command(
+                        self.lock.toolchain, requested_command[0], *requested_command[1:]
+                    )
+                raw = self.manager.backend.execute(
+                    command,
+                    cwd=instance,
+                    environment=execution_environment,
+                    policy=policy,
+                    cancel=cancel,
                 )
-            raw = self.manager.backend.execute(
-                command,
-                cwd=instance,
-                environment=self.manager.toolchains.environment,
-                policy=policy,
-                cancel=cancel,
-            )
             if operation == "check" and preliminary:
                 raw = BackendResult(
                     exit_code=raw.exit_code,

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/lean_runtime/runtime.py

@@ -42,7 +42,7 @@ from .profiling import ProfileReport, run_profile
 from .programs import ProgramInfo, ProgramLibrary, ProgramManager, ReadyProgram
 from .projects import ProjectContext, ProjectEnvironment, discover_project
 from .publisher_verification import CosignVerifier
-from .references import PackageReference, discover_package, normalize_references
+from .references import PACKAGE_ALIASES, PackageReference, discover_package, normalize_references
 from .resolver import EnvironmentResolver
 from .serialization import sha256_id, sha256_text
 from .specs import EnvironmentSpec, GitPackage
@@ -66,6 +66,38 @@ from .verification import (
 EnvironmentReference = Environment | EnvironmentSpec | EnvironmentLock | str
 
 
+def _bundled_lock_for_references(
+    packages: Sequence[str | PackageReference], toolchain: str | None
+) -> EnvironmentLock | None:
+    """Match a single exact alias tag to its bundled, downloadable catalog lock."""
+    references = normalize_references(packages)
+    if len(references) != 1:
+        return None
+    reference = references[0]
+    if reference.revision_kind != "tag":
+        return None
+    alias = next(
+        (
+            name
+            for name, (owner, repository, _command) in PACKAGE_ALIASES.items()
+            if reference.url == f"https://github.com/{owner}/{repository}.git"
+        ),
+        None,
+    )
+    if alias is None:
+        return None
+    entry_id = f"{alias}-{reference.revision}"
+    # Imported lazily: discovery's probe layer also imports Runtime.
+    from .discovery.defaults import default_catalog
+
+    entry = next((item for item in default_catalog().entries if item.id == entry_id), None)
+    if entry is None:
+        return None
+    if toolchain is not None and normalize_toolchain(toolchain) != entry.toolchain:
+        return None
+    return entry.lock
+
+
 def _download_reason(error: Exception) -> str:
     message = str(error).lower()
     if "platform" in message or "compatible" in message:
@@ -631,6 +663,14 @@ class Runtime:
         cancel: threading.Event | None = None,
     ) -> EnvironmentLock:
         """Discover package references and resolve their exact Lake graph."""
+        catalog_lock = _bundled_lock_for_references(packages, toolchain)
+        if catalog_lock is not None:
+            self.events.emit(
+                "catalog.reference_matched",
+                "Using bundled exact environment for package reference",
+                lock_id=catalog_lock.lock_id,
+            )
+            return catalog_lock
         return self.prepare(
             self.spec_from_references(packages, toolchain=toolchain),
             timeout=timeout,

{lean_runtime-2.1.2 → lean_runtime-2.2.0/lean_runtime.egg-info}/PKG-INFO

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

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/pyproject.toml

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

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/scripts/announcement_gate.py

@@ -35,8 +35,10 @@ from pathlib import Path
 ACCEPTANCE = Path(__file__).resolve().parent.parent / "acceptance"
 
 COLD_TIMEOUT = 2700  # toolchain download + environment download, no builds
-WARM_TIMEOUT = 300
-WARM_LIMIT = 240  # warm Mathlib checks include a full Lake trace scan today
+WARM_TIMEOUT = 600
+WARM_LIMIT = 400  # hang detector, not a perf bar: GitHub macOS runners take ~4x
+# longer than real hardware for the warm Lake trace scan (238s observed vs 38s
+# on an M-series laptop)
 
 
 def run(
@@ -169,7 +171,7 @@ def main() -> int:
     ok = ok and step(
         "python-batch-api",
         [sys.executable, str(ACCEPTANCE / "python_api.py"), str(lock_path)],
-        timeout=900,
+        timeout=1500,
     )
 
     usage = shutil.disk_usage(home)

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/tests/test_multifile.py

@@ -3,7 +3,12 @@ from __future__ import annotations
 import pytest
 
 from lean_runtime import EnvironmentError, EnvironmentLock, LockedPackage
-from lean_runtime.environments import _package_import_targets, _source_files, _support_order
+from lean_runtime.environments import (
+    _check_lean_paths,
+    _package_import_targets,
+    _source_files,
+    _support_order,
+)
 
 
 def test_nested_lean_sources_are_normalized() -> None:
@@ -55,3 +60,34 @@ def test_package_import_targets_exclude_core_and_submitted_modules() -> None:
         "Main.lean": "import Init\nimport Local\nimport ProofWidgets.Util",
     }
     assert _package_import_targets(files, lock) == ("ProofWidgets",)
+
+
+def test_check_lean_paths_include_scratch_root_and_compiled_packages(tmp_path) -> None:
+    lock = EnvironmentLock(
+        toolchain="leanprover/lean4:v4.32.0",
+        spec_digest="spec_" + "a" * 64,
+        root_lakefile='name = "test"\n',
+        root_module="",
+        manifest={"packages": [], "packagesDir": "vendor"},
+        packages=(
+            LockedPackage(
+                name="sample",
+                url="https://example.test/sample",
+                revision="b" * 40,
+                source_id="source_" + "c" * 64,
+                tree_hash="d" * 40,
+                subdir="lean",
+            ),
+        ),
+    )
+    workspace = tmp_path / "workspace"
+    root_build = workspace / ".lake" / "build" / "lib" / "lean"
+    package_build = workspace / "vendor" / "sample" / "lean" / ".lake" / "build" / "lib" / "lean"
+    root_build.mkdir(parents=True)
+    package_build.mkdir(parents=True)
+
+    assert _check_lean_paths(workspace, tmp_path / "scratch", lock) == (
+        tmp_path / "scratch" / ".lake" / "build" / "lib" / "lean",
+        package_build,
+        root_build,
+    )

{lean_runtime-2.1.2 → lean_runtime-2.2.0}/tests/test_runtime.py

@@ -7,7 +7,18 @@ from pathlib import Path
 
 import pytest
 
-from lean_runtime import EnvironmentSpec, ExecutionJob, ResolutionError, Runtime, ToolchainError
+from lean_runtime import (
+    EnvironmentLock,
+    EnvironmentSpec,
+    ExecutionJob,
+    ResolutionError,
+    Runtime,
+    ToolchainError,
+)
+from lean_runtime.backends import LocalBackend
+from lean_runtime.environments import Environment, EnvironmentManager
+from lean_runtime.runtime import _bundled_lock_for_references
+from lean_runtime.store import EnvironmentStore
 
 
 class FakeToolchains:
@@ -35,6 +46,54 @@ class FakeToolchains:
         return [sys.executable, "-c", "raise SystemExit(0)"]
 
 
+def test_exact_mathlib_reference_matches_bundled_catalog_lock() -> None:
+    lock = _bundled_lock_for_references(["mathlib@v4.32.2"], None)
+    assert lock is not None
+    assert lock.toolchain == "leanprover/lean4:v4.32.2"
+    assert any(package.name == "mathlib" for package in lock.packages)
+
+
+def test_catalog_reference_match_respects_context_and_toolchain() -> None:
+    assert _bundled_lock_for_references(["mathlib@main"], None) is None
+    assert _bundled_lock_for_references(["mathlib@v4.32.2", "leancert@main"], None) is None
+    assert _bundled_lock_for_references(["mathlib@v4.32.2"], "v4.31.0") is None
+
+
+def test_environment_check_does_not_clone_published_workspace(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    store = EnvironmentStore(tmp_path / "runtime")
+    environment_id = "env_" + "a" * 64
+    root = store.environment_path(environment_id)
+    (root / "workspace" / ".lake" / "build" / "lib" / "lean").mkdir(parents=True)
+    lock = EnvironmentLock(
+        toolchain="leanprover/lean4:v4.32.0",
+        spec_digest="spec_" + "b" * 64,
+        root_lakefile='name = "test"\n',
+        root_module="",
+        manifest={"packages": []},
+        packages=(),
+    )
+    manager = EnvironmentManager(
+        store,
+        FakeToolchains(tmp_path / "runtime"),  # type: ignore[arg-type]
+        LocalBackend(),
+    )
+    environment = Environment(
+        manager,
+        environment_id,
+        lock,
+        root,
+        {"platform": {}, "build_profile": "release", "created_at": "2026-08-12T00:00:00Z"},
+    )
+
+    def unexpected_clone(_source: Path, _destination: Path) -> None:
+        raise AssertionError("checks must not clone a published workspace")
+
+    monkeypatch.setattr("lean_runtime.environments.clone_tree", unexpected_clone)
+    assert environment.check("example : True := by trivial").ok
+
+
 def test_check_accepts_source(tmp_path: Path) -> None:
     runtime = Runtime(toolchains=FakeToolchains(tmp_path))  # type: ignore[arg-type]
     result = runtime.check("example : True := by trivial", toolchain="4.32.0")