lean-runtime 2.0.9__tar.gz → 2.1.1__tar.gz

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/CHANGELOG.md

@@ -1,6 +1,68 @@
 # Changelog
 
-## Unreleased
+## 2.1.1 - 2026-08-12
+
+- The discovery search budget now gates starting additional candidates and
+  no longer kills an in-flight authoritative check, which is bounded by its
+  own per-candidate timeout. A slow machine's first Mathlib check can outlive
+  the remaining search budget legitimately.
+- OCI blob downloads keep partials on truncated transfers and resume with a
+  Range request, retry transport errors mid-stream, and attempt four times.
+- Add `build-and-publish --accelerate`: hydrate artifacts from known package
+  caches (Mathlib's `lake exe cache get`) for locked packages that carry no
+  artifact command of their own. Acceleration is keyed by exact canonical
+  package URL, never changes the lock identity, is recorded in the hydration
+  report, and the built environment is still probe-verified before
+  publication. The public-cache workflow uses it, turning multi-hour Mathlib
+  source builds into minutes.
+- Add a fail-closed release toolkit: `scripts/registry_preflight.py` verifies
+  every bundled catalog entry is anonymously downloadable, and the
+  announcement-gate workflow runs the advertised PyPI journeys on clean
+  unauthenticated Linux and macOS runners (dispatch + daily canary).
+- `lean-run` now warns loudly when a downloadable environment is unavailable
+  and states that source builds can take 30+ minutes, with a
+  `--no-source-build` hint, instead of falling back silently.
+
+## 2.1.0 - 2026-08-11
+
+- Add `lean-runtime toolchain-slim` and
+  `ToolchainManager.materialize_slim()`: a verified check-profile toolchain
+  copy that drops editor indexes, static libraries, bundled LLVM/clang, and
+  sources (about 2.6 GB → 2.1 GB for v4.32.2 once `--prune-original` removes
+  the full Elan copy). Materialization hardlinks files, verification runs a
+  capability corpus with the slim copy's own `lean`, and checking transparently
+  routes through the slim copy when the full toolchain is absent. Lean v4.32
+  requires all `.olean` facets and per-module IR for ordinary elaboration, so
+  those remain; source builds of new environments still need the full
+  toolchain.
+
+- Exempt environment acquisition (downloads, toolchain installs, source
+  builds) from the discovery search budget: a slow first-time download can no
+  longer expire an otherwise healthy search. Acquisition is bounded separately
+  by `DiscoveryPolicy.acquisition_timeout_seconds` and `lean-run
+  --acquire-timeout`; `--search-timeout` and `--check-timeout` name the
+  remaining budgets, with `--discovery-timeout` and `--timeout` kept as
+  deprecated aliases.
+- Split the candidate probe into `acquire` and `check` phases and announce
+  first-time toolchain installation through a `toolchain.install_started`
+  event and a `lean-run` progress line. `CandidateProbe` implementers must now
+  provide both methods; `acquire` returns the newly exported
+  `AcquiredCandidate`, and its acquisition budget is forwarded to
+  `open_exact(build_timeout=...)` so `--acquire-timeout` governs source
+  builds.
+- Add `ExecutionResult.errors`, `.warnings`, and `.first_error` severity views,
+  a `Diagnostic.location` property, and compact `repr` output for both types.
+  `to_dict()` payloads are unchanged.
+- Report structured diagnostics against the caller's logical input names
+  (for example `Main.lean`) instead of staged sandbox paths, and rewrite the
+  staged entrypoint path back to the user's file in `lean-run` text output.
+  Raw `stdout`/`stderr` remain authoritative and unmodified in results.
+- Add `lean.setup(toolchain="v4.32.2")` and `Runtime.open_toolchain()` for
+  reusable core-only environments; the empty-`deps` error now teaches the
+  toolchain form.
+- Accept an exact lock path anywhere `lean-runtime profile` previously
+  required an environment name (`Runtime.subject_environment`); a path that
+  exists on disk always wins over an environment name.
 
 ## 2.0.9 - 2026-08-10
 

{lean_runtime-2.0.9/lean_runtime.egg-info → lean_runtime-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.9
+Version: 2.1.1
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -131,6 +131,24 @@ result = env.check(
 result.raise_for_error()
 ```
 
+Rejected proofs carry parsed diagnostics:
+
+```python
+result = env.check(broken_proof)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+result.raise_for_error()  # raises LeanCheckError with the same detail
+```
+
+Core-only work does not need a dependency:
+
+```python
+core = lean.setup(toolchain="v4.32.2")
+core.check("example : 2 + 2 = 4 := rfl").raise_for_error()
+```
+
 Batch and asyncio APIs reuse that prepared environment:
 
 ```python

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/README.md

@@ -96,6 +96,24 @@ result = env.check(
 result.raise_for_error()
 ```
 
+Rejected proofs carry parsed diagnostics:
+
+```python
+result = env.check(broken_proof)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+result.raise_for_error()  # raises LeanCheckError with the same detail
+```
+
+Core-only work does not need a dependency:
+
+```python
+core = lean.setup(toolchain="v4.32.2")
+core.check("example : 2 + 2 = 4 := rfl").raise_for_error()
+```
+
 Batch and asyncio APIs reuse that prepared environment:
 
 ```python

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/cli.md

@@ -18,9 +18,14 @@ lean-run Main.lean --offline
 
 Without explicit context or a pinned Lake project, `lean-run` automatically
 searches its bundled exact-environment catalog. Use `--lock-out` to retain the
-successful lock, `--no-discover` to require explicit context,
-`--catalog PATH` to override the catalog, and `--max-candidates` plus
-`--discovery-timeout` to bound search. See
+successful lock, `--no-discover` to require explicit context, and
+`--catalog PATH` to override the catalog. Three budgets bound the work:
+`--search-timeout` covers ranking and compiler probes, `--check-timeout`
+covers each Lean invocation, and `--acquire-timeout` independently bounds
+downloading, installing, or building one candidate environment, so a slow
+first-time download cannot expire the search. `--discovery-timeout` and
+`--timeout` remain as deprecated aliases of `--search-timeout` and
+`--check-timeout`. See
 [Standalone Lean files](standalone-files.md) for routing and policy details.
 
 ## `lean-runtime`
@@ -79,6 +84,34 @@ identity, package Git trees, computer compatibility, and Lean probe before
 making the environment available. See [Portable copies and environment
 libraries](portable-copies.md) for its trust boundary.
 
+## Slim toolchains
+
+The official Lean toolchain is roughly 2.6 GB installed. Proof checking does
+not need all of it: editor indexes, static libraries, the bundled LLVM/clang,
+and toolchain sources are only used by editors and native compilation.
+
+```bash
+lean-runtime toolchain-slim v4.32.2
+lean-runtime toolchain-slim v4.32.2 --prune-original
+```
+
+`toolchain-slim` materializes a separate check-profile copy by hardlinking the
+kept files (near-zero extra disk), then verifies it against a capability
+corpus — elaboration, core tactics, `decide`, `#eval`, metaprogramming, and
+`Std` imports — using the slim copy's own `lean`. A copy that fails any probe
+is removed and reported.
+
+`--prune-original` uninstalls the full Elan toolchain after verification,
+reducing the v4.32.2 footprint from about 2.6 GB to about 2.1 GB. All checking
+continues through the slim copy. Lean v4.32 loads every `.olean` facet and
+per-module IR during ordinary elaboration, so those artifact classes must
+stay; larger reductions require upstream facet-loading changes.
+
+After pruning, source builds of *new* environments and native compilation
+need the full toolchain again; reinstall it with `lean-runtime install`.
+Downloads are unaffected: first-time installation still transfers the full
+official release before a slim copy can be derived from it.
+
 ## Replay
 
 ```bash

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/development.md

@@ -78,3 +78,26 @@ a normal publisher and creates the PyPI project.
 PyPI does not permit replacing files for an already published version. If a
 release needs a correction, increment the version rather than recreating the
 tag.
+
+## Release and announcement protocol
+
+Catalog entries are public claims that a prebuilt environment is
+downloadable. The protocol below makes those claims fail-closed:
+
+1. Publish downloadable environments for every catalog entry and platform
+   (`public-cache.yml`) **before** shipping a wheel that references them, and
+   make the GHCR package publicly pullable.
+2. Run `python scripts/registry_preflight.py` — it verifies, anonymously,
+   that every catalog lock resolves to an index, platform manifests, and
+   readable blobs. CI-cheap; run it on every release.
+3. After publishing to PyPI, dispatch the **Announcement gate** workflow
+   (`announcement-gate.yml`). It installs from PyPI on clean unauthenticated
+   Linux and macOS runners and runs the advertised journeys from
+   `acceptance/`: a cold check with `--no-source-build` (fail-closed: a
+   broken registry fails in seconds instead of hiding behind a source
+   build), a warm re-check, a failing proof with logical diagnostic paths, a
+   lock round-trip, and the Python batch API. Release titles use `vX.Y.Z`,
+   matching the tag.
+4. Announce only after the gate is green. The same workflow runs daily as a
+   canary: registry permissions and docs deployments can break without any
+   code change.

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/getting-started.md

@@ -75,17 +75,27 @@ result.raise_for_error()
 `setup()` resolves and ensures the environment once. Further checks reuse that
 handle, including batch and asynchronous calls.
 
-The same entry point opens local projects, exact locks, and previously named
-environments:
+The same entry point opens local projects, exact locks, previously named
+environments, and core-only toolchains:
 
 ```python
 project = lean.setup(project="./my-project")
 locked = lean.setup(lock="environment.lock.json")
 existing = lean.setup(environment="research-stack")
+core = lean.setup(toolchain="v4.32.2")
 ```
 
 Exactly one context must be supplied.
 
+Rejected checks expose parsed diagnostics directly, with `file` naming your
+logical input:
+
+```python
+result = environment.check(broken_proof)
+for error in result.errors:
+    print(error.file, error.line, error.message)
+```
+
 ## Lock for CI
 
 Resolve a friendly dependency declaration and retain its exact graph:

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/python-api.md

@@ -12,9 +12,13 @@ environment = lean.setup(["mathlib@v4.32.2"])
 project = lean.setup(project="./my-project")
 locked = lean.setup(lock="environment.lock.json")
 existing = lean.setup(environment="research-stack")
+core = lean.setup(toolchain="v4.32.2")
 ```
 
-Exactly one of `deps`, `project`, `lock`, or `environment` is required. The
+Exactly one of `deps`, `project`, `lock`, `environment`, or a bare
+`toolchain` is required. A bare `toolchain` prepares the core-only
+environment for that Lean release; combined with `deps` or `project` it
+remains an override. The
 default `Runtime` is created lazily on the first operation; importing
 `lean_runtime` has no filesystem or network side effects. Supply
 `runtime=Runtime(...)` to any façade function for explicit configuration.
@@ -53,7 +57,24 @@ runs. Planning metadata narrows candidates but never asserts compatibility.
 
 ## Results
 
-Results remain inspectable values. Scripts that prefer exceptions can use:
+Results remain inspectable values. Failed checks expose their parsed
+diagnostics directly:
+
+```python
+result = environment.check(source)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+if result.first_error is not None:
+    print(result.first_error.location)
+```
+
+`errors` and `warnings` are severity-filtered views of `diagnostics`;
+`first_error` returns the first error or `None`. Diagnostic `file` values name
+the caller's logical input (for example `Main.lean`); raw compiler output
+remains authoritative on `stdout`/`stderr` and may contain physical sandbox
+paths. Scripts that prefer exceptions can use:
 
 ```python
 result.raise_for_error()

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/standalone-files.md

@@ -15,9 +15,21 @@ environment is compatible. Runtime materializes each bounded candidate and
 Lean authoritatively checks the source before discovery can succeed.
 
 The bundled bootstrap catalog contains core Lean v4.32.2 plus exact Mathlib
-v4.32.2, v4.31.0, and v4.30.0 locks. `--catalog PATH` selects another validated catalog,
-`--max-candidates` and `--discovery-timeout` bound the search, and
-`--no-discover` restores strict explicit-context behavior.
+v4.32.2, v4.31.0, and v4.30.0 locks. `--catalog PATH` selects another validated
+catalog and `--no-discover` restores strict explicit-context behavior.
+
+Three budgets bound the work independently:
+
+- `--max-candidates` and `--search-timeout` bound the search itself: ranking
+  plus compiler probes.
+- `--check-timeout` bounds each Lean invocation.
+- `--acquire-timeout` bounds downloading, installing, or building one
+  candidate environment, including its source build. Acquisition never
+  consumes the search budget, so a slow first-time toolchain download cannot
+  expire an otherwise healthy search.
+
+`--discovery-timeout` and `--timeout` remain as deprecated aliases of
+`--search-timeout` and `--check-timeout`.
 
 ## Frontmatter format
 
@@ -53,12 +65,21 @@ environments only.
 
 ## Output
 
-Human output is concise:
+Human output is concise, and error locations name the file you passed rather
+than an internal staging path:
 
 ```text
 ✓ Main.lean accepted in 0.42s
 ```
 
+```text
+proofs/Bad.lean:1:23: error: Type mismatch
+✗ proofs/Bad.lean rejected in 0.35s
+```
+
+Only the checked file's own path is rewritten; dependency paths in compiler
+output are shown as Lean printed them.
+
 Cold operations report meaningful dependency, cache, and build phases on
 stderr. `--quiet` suppresses progress and `--json` emits the complete structured
 `ExecutionResult` without progress messages.

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/docs/trust-and-limitations.md

@@ -2,7 +2,7 @@
 
 ## Trusted local execution
 
-Lean Runtime 0.5 orchestrates trusted code. It is not a sandbox.
+Lean Runtime orchestrates trusted code. It is not a sandbox.
 
 Lake configurations are executable, dependencies may contain native code and
 custom build targets, and explicit artifact commands run subprocesses. Lockfile

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/lean_runtime/cli.py

@@ -153,6 +153,13 @@ def parser() -> argparse.ArgumentParser:
         action="store_true",
         help="publish blobs and platform manifest without updating the lock index",
     )
+    push.add_argument(
+        "--accelerate",
+        action="store_true",
+        help="hydrate artifacts from known package caches (e.g. Mathlib's) for locked "
+        "packages without an artifact command; the lock identity is unchanged and the "
+        "built environment is still probe-verified before publication",
+    )
     push.add_argument("--sign", action="store_true", help="sign the published lock index")
     push.add_argument(
         "--attest", action="store_true", help="publish a signed source/probe attestation"
@@ -271,8 +278,21 @@ def parser() -> argparse.ArgumentParser:
     diff.add_argument("right")
     diff.add_argument("--json", action="store_true")
 
+    toolchain_slim = commands.add_parser(
+        "toolchain-slim",
+        help="materialize a verified slim check-profile copy of a toolchain",
+    )
+    toolchain_slim.add_argument("toolchain", help="Lean toolchain, e.g. v4.32.2")
+    toolchain_slim.add_argument(
+        "--prune-original",
+        action="store_true",
+        help="uninstall the full Elan toolchain after verification; checking keeps "
+        "working through the slim copy, but source builds of new environments and "
+        "native compilation need the full toolchain again",
+    )
+
     profile = commands.add_parser("profile", help="measure repeated checks in one environment")
-    profile.add_argument("environment")
+    profile.add_argument("environment", help="environment name or exact lock path")
     profile.add_argument("file", type=Path)
     profile.add_argument("--warmup", type=int, default=1)
     profile.add_argument("--repeat", type=int, default=5)
@@ -378,6 +398,7 @@ def main(argv: list[str] | None = None) -> int:
                 EnvironmentLock.load(args.lock),
                 name=args.name,
                 build_timeout=args.timeout,
+                accelerate=args.accelerate,
             )
             _json(
                 runtime.publish_environment(
@@ -519,6 +540,18 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "storage":
             _json(runtime.store_status().to_dict())
             return 0
+        if args.command == "toolchain-slim":
+            manifest = runtime.toolchains.materialize_slim(args.toolchain)
+            if args.prune_original:
+                runtime.toolchains.prune_original(args.toolchain)
+            _json(
+                {
+                    **manifest.to_dict(),
+                    "path": str(runtime.toolchains.slim_path(args.toolchain)),
+                    "pruned_original": args.prune_original,
+                }
+            )
+            return 0
         if args.command == "doctor":
             doctor_report = runtime.doctor()
             _json(doctor_report.to_dict())

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/lean_runtime/diagnostics.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Mapping
+from dataclasses import replace
 
 from .models import Diagnostic, Severity
 
@@ -46,6 +48,26 @@ def parse_diagnostics(output: str) -> tuple[Diagnostic, ...]:
     return tuple(diagnostics)
 
 
+def map_diagnostic_paths(
+    diagnostics: tuple[Diagnostic, ...],
+    path_map: Mapping[str, str] | None,
+) -> tuple[Diagnostic, ...]:
+    """Rewrite staged physical paths to the caller's logical input names.
+
+    Only exact staged-file matches are rewritten; package files may
+    legitimately share basenames, and raw compiler output remains authoritative
+    on the execution result.
+    """
+    if not path_map:
+        return diagnostics
+    return tuple(
+        replace(item, file=path_map[item.file])
+        if item.file is not None and item.file in path_map
+        else item
+        for item in diagnostics
+    )
+
+
 def error_diagnostic(message: str) -> Diagnostic:
     """Create an infrastructure diagnostic."""
     severity: Severity = "error"

{lean_runtime-2.0.9 → lean_runtime-2.1.1}/lean_runtime/discovery/__init__.py

@@ -21,7 +21,7 @@ from .defaults import DEFAULT_CATALOG_PATH, default_catalog
 from .errors import CatalogError, DiscoveryError, PolicyError
 from .planner import Planner
 from .policy import DiscoveryPolicy
-from .probe import CandidateProbe, LeanRuntimeProbe, ProbeOutcome
+from .probe import AcquiredCandidate, CandidateProbe, LeanRuntimeProbe, ProbeOutcome
 from .result import (
     RESULT_SCHEMA,
     CandidateAttempt,
@@ -39,6 +39,7 @@ __all__ = [
     "AvailabilityObservation",
     "Candidate",
     "CandidateAttempt",
+    "AcquiredCandidate",
     "CandidateProbe",
     "CandidateReason",
     "Catalog",