lean-runtime 4.22.0__tar.gz → 4.24.0__tar.gz

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 4.24.0 - 2026-08-26
+
+- Key shared Lake package artifacts by the exact installed Lean and Lake
+  executable digests. Existing `/1` package artifacts are source-only donors;
+  the first build of each project re-shares artifacts under the `/2` key.
+- Let an exact registered dependency graph donate source across toolchain
+  versions, while stripping its build tree, and refresh existing project
+  attachments when their computed workspace identity changes.
+- Report obsolete `/1` project artifacts in `doctor`, reclaim them through
+  `clean`, and refuse publishing moving toolchain spellings such as `master`
+  or undated `nightly`. Publication also fails early when its input is an
+  acquired sparse capsule rather than a source build.
+
+## 4.23.0 - 2026-08-24
+
 ## 4.22.0 - 2026-08-23
 
 ## 4.21.0 - 2026-08-23

{lean_runtime-4.22.0/lean_runtime.egg-info → lean_runtime-4.24.0}/PKG-INFO

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

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/cli.py

@@ -119,18 +119,20 @@ def _render_storage(status: StoreStatus) -> None:
         ("Executions", status.executions, status.executions_bytes),
         ("Scratch", status.scratch_workspaces, status.scratch_bytes),
     )
+    label_width = max(len(label) for label, _count, _bytes in rows)
+    count_width = max(8, *(len(str(count)) for _label, count, _bytes in rows if count is not None))
     for label, count, bytes_used in rows:
-        counted = f"{count:>5}" if count is not None else "     "
+        counted = f"{count:>{count_width}}" if count is not None else " " * count_width
         size_column = style.cyan(f"{format_byte_size(bytes_used):>10}")
-        print(f"  {label:<15}{counted}  {size_column}")
-    total_label = style.bold(f"{'Materialized':<15}")
+        print(f"  {label:<{label_width}} {counted}  {size_column}")
+    total_label = style.bold(f"{'Materialized':<{label_width}}")
     total_size = style.bold(f"{format_byte_size(status.bytes_used):>10}")
     free_note = style.dim(f"({format_byte_size(status.bytes_free)} free on disk)")
-    print(f"  {total_label}       {total_size}  {free_note}")
+    print(f"  {total_label} {' ' * count_width}  {total_size}  {free_note}")
     if status.allocated_bytes:
-        allocated_label = style.bold(f"{'Allocated*':<15}")
+        allocated_label = style.bold(f"{'Allocated*':<{label_width}}")
         allocated_size = style.bold(f"{format_byte_size(status.allocated_bytes):>10}")
-        print(f"  {allocated_label}       {allocated_size}")
+        print(f"  {allocated_label} {' ' * count_width}  {allocated_size}")
         print(style.dim("  * hard links counted once; copy-on-write blocks may still be shared"))
     if status.environment_usage:
         print()
@@ -177,6 +179,7 @@ def _render_cleanup(
     environments: CleanupReport,
     downloads: DownloadCleanupReport | None,
     scratch: CleanupReport | None = None,
+    project_artifacts: CleanupReport | None = None,
 ) -> None:
     style = styler_for(sys.stdout)
     retained_note = style.dim(
@@ -218,6 +221,17 @@ def _render_cleanup(
                 )
             else:
                 print("No abandoned workspaces to remove.")
+        if project_artifacts is not None:
+            if project_artifacts.candidates:
+                anything = True
+                print(
+                    style.bold(
+                        f"Would remove {len(project_artifacts.candidates)} obsolete project "
+                        f"artifact tree(s) · {format_byte_size(project_artifacts.candidate_bytes)}"
+                    )
+                )
+            else:
+                print("No obsolete /1 project artifacts to remove.")
         print(retained_note)
         if anything:
             print()
@@ -226,10 +240,13 @@ def _render_cleanup(
     reclaimed = environments.reclaimed_bytes + (downloads.reclaimed_bytes if downloads else 0)
     if scratch is not None:
         reclaimed += scratch.reclaimed_bytes
+    if project_artifacts is not None:
+        reclaimed += project_artifacts.reclaimed_bytes
     removed = (
         len(environments.removed)
         + (len(downloads.removed) if downloads else 0)
         + (len(scratch.removed) if scratch else 0)
+        + (len(project_artifacts.removed) if project_artifacts else 0)
     )
     if removed:
         parts = [f"{len(environments.removed)} environment(s)"]
@@ -237,6 +254,8 @@ def _render_cleanup(
             parts.append(f"{len(downloads.removed)} cached download(s)")
         if scratch is not None:
             parts.append(f"{len(scratch.removed)} abandoned workspace(s)")
+        if project_artifacts is not None:
+            parts.append(f"{len(project_artifacts.removed)} obsolete project artifact tree(s)")
         print(
             style.green(f"Removed {' and '.join(parts)} · reclaimed {format_byte_size(reclaimed)}")
         )
@@ -886,6 +905,13 @@ Advanced namespaces:
     adopt.add_argument(
         "--dry-run", action="store_true", help="show the adoption plan without changing anything"
     )
+    adopt.add_argument(
+        "--no-agents",
+        dest="agents",
+        action="store_false",
+        default=True,
+        help="skip generating AGENTS.md",
+    )
     _add_common_output(adopt)
     adopt.set_defaults(command="attach", recursive=None, execute=False)
 
@@ -1150,6 +1176,13 @@ Advanced namespaces:
     pshare.add_argument(
         "--dry-run", action="store_true", help="show the sharing plan without changing anything"
     )
+    pshare.add_argument(
+        "--no-agents",
+        dest="agents",
+        action="store_false",
+        default=True,
+        help="skip generating AGENTS.md",
+    )
     _add_common_output(pshare)
     pshare.set_defaults(command="attach", recursive=None, execute=False)
     punshare = pc.add_parser("unshare", help="materialize independent dependency copies")
@@ -1679,9 +1712,19 @@ def main(argv: list[str] | None = None) -> int:
                 if args.agents:
                     print(f"Agent guide: {init_result.root / 'AGENTS.md'}")
                 project_name = init_plan.project_name or init_result.root.name
-                print(
-                    f"Next: cd {init_result.root} && lean-runtime check {project_name}/Basic.lean"
+                # Lake capitalizes the module directory during `lake init`, so derive
+                # the hint from the file it actually created rather than the raw name.
+                created = sorted(
+                    path
+                    for path in init_result.root.glob("*/Basic.lean")
+                    if not path.parent.name.startswith(".")
+                )
+                module_file = (
+                    created[0].relative_to(init_result.root)
+                    if created
+                    else Path(project_name) / "Basic.lean"
                 )
+                print(f"Next: cd {init_result.root} && lean-runtime check {module_file}")
             return 0
         if args.command == "scan":
             scan_result = runtime.scan_projects(args.path, recursive=args.recursive)
@@ -1793,8 +1836,24 @@ def main(argv: list[str] | None = None) -> int:
                 recursive=args.recursive,
                 plan=adoption_plan,
             )
+            # Adoption is the canonical moment a repository becomes agent-ready,
+            # including re-runs against already-attached projects.
+            agent_guides = (
+                [
+                    guide
+                    for attached in adoption_result.results
+                    if (guide := runtime.write_agents_guide(attached.root)) is not None
+                ]
+                if args.agents
+                else []
+            )
             if args.json:
-                _json(adoption_result.to_dict())
+                _json(
+                    {
+                        **adoption_result.to_dict(),
+                        "agent_guides": [str(guide) for guide in agent_guides],
+                    }
+                )
             else:
                 _render_adoption_plan(adoption_result.plan)
                 for attached in adoption_result.results:
@@ -1802,6 +1861,8 @@ def main(argv: list[str] | None = None) -> int:
                         f"{attached.action}: {attached.root} · "
                         f"{format_byte_size(attached.reclaimed_bytes)} replaced"
                     )
+                for guide in agent_guides:
+                    print(f"Agent guide: {guide}")
                 for root, message in adoption_result.failures:
                     print(f"failed: {root}: {message}", file=sys.stderr)
             return 0 if adoption_result.ok else 1
@@ -1958,6 +2019,10 @@ def main(argv: list[str] | None = None) -> int:
                 name=args.name,
                 build_timeout=args.timeout,
                 accelerate=args.accelerate,
+                # Acquire means the whole environment: demanding the root
+                # module keeps a sparse capsule from satisfying it with an
+                # empty closure that only looks ready.
+                import_roots=(ROOT_MODULE,),
             )
             _json(environment.inspect().to_dict())
             if args.timings:
@@ -2252,12 +2317,22 @@ def main(argv: list[str] | None = None) -> int:
                     "toolchain": project_status.toolchain,
                     "manifest": str(project_status.manifest) if project_status.manifest else None,
                     "attached": (project_status.root / "lean-runtime.toml").is_file(),
+                    "agents_guide": (
+                        str(project_status.root / "AGENTS.md")
+                        if (project_status.root / "AGENTS.md").is_file()
+                        else None
+                    ),
                 }
             if args.json:
                 _json(status_payload)
             else:
-                print(f"{status_payload['kind'].title()}")
-                for key, value in status_payload.items():
+                display_payload = dict(status_payload)
+                if display_payload.get("kind") == "project" and (
+                    display_payload.get("agents_guide") is None
+                ):
+                    display_payload["agents_guide"] = "missing (`lean-runtime adopt` writes one)"
+                print(f"{display_payload['kind'].title()}")
+                for key, value in display_payload.items():
                     if key == "kind":
                         continue
                     label = key.replace("_", " ").title()
@@ -2402,12 +2477,19 @@ def main(argv: list[str] | None = None) -> int:
                 dry_run=True,
                 minimum_age_seconds=min(args.minimum_age_hours * 3600, 3600),
             )
+            preview_project_artifacts = runtime.clean_legacy_project_artifacts(dry_run=True)
             if not args.json:
-                _render_cleanup(cleanup_preview, preview_downloads, preview_scratch)
+                _render_cleanup(
+                    cleanup_preview,
+                    preview_downloads,
+                    preview_scratch,
+                    preview_project_artifacts,
+                )
             has_candidates = bool(
                 cleanup_preview.candidates
                 or (preview_downloads and preview_downloads.candidates)
                 or preview_scratch.candidates
+                or preview_project_artifacts.candidates
             )
             if has_candidates and not args.dry_run:
                 execute_cleanup = _confirm("Remove these files?", yes=args.yes, json_mode=args.json)
@@ -2428,11 +2510,15 @@ def main(argv: list[str] | None = None) -> int:
                 dry_run=not execute_cleanup,
                 minimum_age_seconds=min(args.minimum_age_hours * 3600, 3600),
             )
+            gc_project_artifacts = runtime.clean_legacy_project_artifacts(
+                dry_run=not execute_cleanup
+            )
             if args.json:
                 gc_payload: dict[str, Any] = {
                     "environments": gc_report.to_dict(),
                     "downloaded_files": gc_downloads.to_dict() if gc_downloads else None,
                     "scratch": gc_scratch.to_dict(),
+                    "project_artifacts": gc_project_artifacts.to_dict(),
                 }
                 _json(
                     envelope(
@@ -2442,7 +2528,7 @@ def main(argv: list[str] | None = None) -> int:
                     )
                 )
             elif execute_cleanup:
-                _render_cleanup(gc_report, gc_downloads, gc_scratch)
+                _render_cleanup(gc_report, gc_downloads, gc_scratch, gc_project_artifacts)
             return 0
         if args.command == "check":
             if args.across is not None:
@@ -2547,7 +2633,7 @@ def main(argv: list[str] | None = None) -> int:
                 watched = Path(args.inputs[0]).expanduser().resolve()
                 if not watched.is_file():
                     raise ValueError(f"watched Lean file does not exist: {watched}")
-                print(f"Watching {watched} · Ctrl-C to stop")
+                print(f"Watching {watched} · Ctrl-C to stop", flush=True)
                 if os.environ.get(_HEADER_SNAPSHOTS_VARIABLE) is None:
                     runtime.header_cache.enabled = True
                 previous: tuple[int, int] | None = None
@@ -2563,6 +2649,7 @@ def main(argv: list[str] | None = None) -> int:
                             policy=_policy(args),
                         )
                         _emit_result(watched_result, False)
+                        sys.stdout.flush()
                     time.sleep(args.watch_interval)
             check_subject = (
                 Path(args.inputs[-1]).name
@@ -2614,10 +2701,16 @@ def main(argv: list[str] | None = None) -> int:
                     if args.include:
                         raise ValueError("local project checks do not accept --include")
                     display_path = "<stdin>"
+                    stdin_project = args.project
+                    if stdin_project is None and args.toolchain is None:
+                        try:
+                            stdin_project = discover_project(Path.cwd()).root
+                        except ProjectNotFoundError:
+                            stdin_project = None
                     result = runtime.check(
                         sys.stdin.read(),
                         toolchain=args.toolchain,
-                        project=args.project,
+                        project=stdin_project,
                         policy=_policy(args),
                     )
                     source_file = None

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/discovery/engine.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import re
 import threading
 import time
 
 from ..errors import LeanRuntimeError
-from .candidate import DiscoveryPlan
+from ..models import ExecutionResult
+from .candidate import Candidate, DiscoveryPlan
+from .catalog import CatalogEntry
 from .probe import CandidateProbe, ProbeIntegrityFailure, ProbeUnavailable
 from .result import (
     AttemptStatus,
@@ -27,6 +30,8 @@ DISCOVERY_EXHAUSTED = "DISCOVERY_EXHAUSTED"
 DISCOVERY_EXPLICIT_LOCK = "DISCOVERY_EXPLICIT_LOCK"
 DISCOVERY_CANCELLED = "DISCOVERY_CANCELLED"
 DISCOVERY_RUNTIME_ERROR = "DISCOVERY_RUNTIME_ERROR"
+DISCOVERY_MODULE_UNAVAILABLE = "DISCOVERY_MODULE_UNAVAILABLE"
+DISCOVERY_VERDICT_BOUNDED = "DISCOVERY_VERDICT_BOUNDED"
 CANDIDATE_LEAN_REJECTED = "CANDIDATE_LEAN_REJECTED"
 CANDIDATE_UNAVAILABLE = "CANDIDATE_UNAVAILABLE"
 CANDIDATE_INTEGRITY_FAILURE = "CANDIDATE_INTEGRITY_FAILURE"
@@ -145,6 +150,63 @@ def _rejection_detail(stderr: str, stdout: str) -> str:
     return stderr.strip() or stdout.strip() or "Lean rejected the source"
 
 
+# Lean reports a missing import as `unknown module prefix 'X'` (directory-shaped
+# roots) or `unknown module 'X'`; both are decidable against candidate
+# inventories without running another compiler.
+_UNKNOWN_MODULE = re.compile(r"unknown module(?: prefix)? '([^']+)'")
+# Identifier-level failures are the rejection class where an older environment
+# legitimately changes the verdict (renamed or deleted lemmas), so they always
+# justify continuing the candidate march.
+_IDENTIFIER_MARKERS = ("unknown identifier", "unknown constant")
+# Positive evidence that the source itself is the problem. Kept deliberately
+# narrow: anything unrecognized preserves the ordinary march.
+_PROOF_LEVEL_MARKERS = ("type mismatch", "unsolved goals", "unexpected token")
+
+
+def _provides_module(entry: CatalogEntry, name: str) -> bool:
+    return name in entry.modules or any(module.startswith(name + ".") for module in entry.modules)
+
+
+def _rejection_verdict(
+    result: ExecutionResult, candidates: tuple[Candidate, ...]
+) -> tuple[str, tuple[str, ...]]:
+    """Classify whether another candidate environment could change a rejection.
+
+    Returns one of:
+    - ``("module_unavailable", names)``: the source imports module roots that no
+      planned candidate provides; every further attempt must fail identically.
+    - ``("source_verdict", ())``: a proof-level failure (type mismatch,
+      unsolved goals, syntax); a second opinion never justifies a fresh
+      download — only local environments or an offline plan's source builds.
+    - ``("march", ())``: everything else — identifier-level failures, modules
+      another candidate does provide, and unclassifiable output all keep the
+      ordinary bounded march.
+    """
+    text = "\n".join(
+        (
+            *(item.message for item in result.diagnostics),
+            result.stderr,
+            result.stdout,
+        )
+    )
+    missing = tuple(dict.fromkeys(_UNKNOWN_MODULE.findall(text)))
+    if missing:
+        unavailable = tuple(
+            name
+            for name in missing
+            if not any(_provides_module(candidate.entry, name) for candidate in candidates)
+        )
+        if unavailable:
+            return "module_unavailable", unavailable
+        return "march", ()
+    lowered = text.lower()
+    if any(marker in lowered for marker in _IDENTIFIER_MARKERS):
+        return "march", ()
+    if any(marker in lowered for marker in _PROOF_LEVEL_MARKERS):
+        return "source_verdict", ()
+    return "march", ()
+
+
 def discover(
     source: str,
     plan: DiscoveryPlan,
@@ -189,6 +251,11 @@ def discover(
         raise ValueError("an authoritative candidate probe is required")
     attempts: list[CandidateAttempt] = []
     remote_acquisitions = 0
+    # Set once a proof-level rejection shows the source itself is the problem:
+    # remaining candidates are only worth a look when reaching them costs no
+    # download (already local, or an offline plan's deliberate source builds).
+    local_candidates_only = False
+    verdict_bounded_skips = 0
     for candidate in plan.planned_candidates:
         if cancel is not None and cancel.is_set():
             return DiscoveryResult(
@@ -217,6 +284,12 @@ def discover(
         candidate_is_local = any(
             reason.code == "RANK_LOCAL_AVAILABLE" for reason in candidate.reasons
         )
+        # A proof-level rejection never justifies a *download*. Offline plans
+        # (allow_download=False) acquire candidates by deliberate local source
+        # builds, so their march is preserved in full.
+        if local_candidates_only and not candidate_is_local and plan.policy.allow_download:
+            verdict_bounded_skips += 1
+            continue
         if not candidate_is_local and remote_acquisitions >= plan.policy.max_remote_acquisitions:
             return DiscoveryResult(
                 status="not_found",
@@ -427,6 +500,29 @@ def discover(
                 duration_seconds=time.monotonic() - started,
                 diagnostics=attempt.diagnostics,
             )
+        if outcome_status == "lean_rejected":
+            verdict, unavailable = _rejection_verdict(result, plan.planned_candidates)
+            if verdict == "module_unavailable":
+                # Statically decidable: no candidate can change this verdict.
+                return DiscoveryResult(
+                    status="not_found",
+                    confidence="exhausted",
+                    outcome="source_rejected",
+                    completion="complete",
+                    plan=plan,
+                    attempts=tuple(attempts),
+                    duration_seconds=time.monotonic() - started,
+                    diagnostics=(
+                        ResultDiagnostic(
+                            DISCOVERY_MODULE_UNAVAILABLE,
+                            "no cataloged environment provides module(s): "
+                            + ", ".join(unavailable),
+                        ),
+                        *attempt.diagnostics,
+                    ),
+                )
+            if verdict == "source_verdict":
+                local_candidates_only = True
 
     if time.monotonic() >= wall_deadline or probe_remaining <= 0:
         reason = ResultDiagnostic(DISCOVERY_TIME_LIMIT, "total wall-clock budget expired")
@@ -465,6 +561,17 @@ def discover(
         if attempt.status == "timeout"
         for diagnostic in attempt.diagnostics
     )
+    skip_diagnostics = (
+        (
+            ResultDiagnostic(
+                DISCOVERY_VERDICT_BOUNDED,
+                f"skipped {verdict_bounded_skips} non-local candidate(s): a proof-level "
+                "rejection does not justify downloading further environments",
+            ),
+        )
+        if verdict_bounded_skips
+        else ()
+    )
     return DiscoveryResult(
         status="not_found",
         confidence=confidence,
@@ -473,5 +580,5 @@ def discover(
         plan=plan,
         attempts=tuple(attempts),
         duration_seconds=time.monotonic() - started,
-        diagnostics=(*timeout_diagnostics, reason, *rejection_diagnostics),
+        diagnostics=(*timeout_diagnostics, reason, *skip_diagnostics, *rejection_diagnostics),
     )

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/environments.py

@@ -766,7 +766,11 @@ class Environment:
                 spawn(
                     resolved_command,
                     cwd=instance,
-                    environment=self.manager.toolchains.environment,
+                    environment=(
+                        self.manager.toolchains.environment_for(self.lock.toolchain)
+                        if requested_command[0] == "lake"
+                        else self.manager.toolchains.environment
+                    ),
                     policy=selected_policy,
                 ),
             )
@@ -905,7 +909,12 @@ class Environment:
                 preliminary: list[BackendResult] = []
                 path_map = {str(instance / name): name for name in files}
                 staging_started = time.monotonic()
-                execution_environment = self.manager.toolchains.environment
+                execution_environment = (
+                    self.manager.toolchains.environment_for(self.lock.toolchain)
+                    if operation == "build"
+                    or (requested_command and requested_command[0] == "lake")
+                    else self.manager.toolchains.environment
+                )
                 if operation == "check":
                     assert entrypoint is not None
                     for name, source in files.items():
@@ -1301,7 +1310,11 @@ class EnvironmentManager:
                 result = self.backend.execute(
                     command,
                     cwd=workspace,
-                    environment=self.toolchains.environment,
+                    environment=(
+                        self.toolchains.environment_for(lock.toolchain)
+                        if requested_command[0] == "lake"
+                        else self.toolchains.environment
+                    ),
                     policy=build_policy,
                     cancel=cancel,
                 )
@@ -1327,7 +1340,7 @@ class EnvironmentManager:
                 result = self.backend.execute(
                     command,
                     cwd=workspace,
-                    environment=self.toolchains.environment,
+                    environment=self.toolchains.environment_for(lock.toolchain),
                     policy=build_policy,
                     cancel=cancel,
                 )

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/health.py

@@ -107,6 +107,20 @@ def diagnose(toolchains: ToolchainManager, store: EnvironmentStore) -> DoctorRep
         )
     else:
         checks.append(DoctorCheck("scratch", "pass", "No abandoned workspaces"))
+    legacy_artifacts = store.clean_legacy_project_artifacts(dry_run=True)
+    if legacy_artifacts.candidates:
+        checks.append(
+            DoctorCheck(
+                "project-artifacts-v1",
+                "warning",
+                f"{len(legacy_artifacts.candidates)} package artifact tree(s) use the obsolete "
+                "toolchain-insensitive /1 key; reclaim them with `lean-runtime clean --yes`",
+            )
+        )
+    else:
+        checks.append(
+            DoctorCheck("project-artifacts-v1", "pass", "No obsolete /1 project artifacts")
+        )
     store_status = store.status()
     cutoff = datetime.now(timezone.utc).timestamp() - STALE_ENVIRONMENT_AGE_HOURS * 3600
     stale = tuple(
@@ -145,6 +159,7 @@ def repair(toolchains: ToolchainManager, store: EnvironmentStore) -> DoctorRepor
         include_legacy=True,
         legacy_minimum_age_seconds=LEGACY_SCRATCH_MINIMUM_AGE_SECONDS,
     )
+    store.clean_legacy_project_artifacts(dry_run=False)
     with suppress(ToolchainError):
         toolchains.elan_path(bootstrap=True)
     return diagnose(toolchains, store)

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/lake_cache.py

@@ -160,7 +160,7 @@ class LakeArtifactCache:
         try:
             process = subprocess.run(
                 self.toolchains.command(toolchain, "lake", *arguments),
-                env=self.toolchains.environment,
+                env=self.toolchains.environment_for(toolchain),
                 text=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
@@ -183,7 +183,7 @@ class LakeArtifactCache:
 
     def environment(self, context: ProjectContext) -> dict[str, str]:
         """Return root-only cache settings without caching dependency packages."""
-        environment = self.toolchains.environment
+        environment = self.toolchains.environment_for(context.toolchain)
         if not self.project_opted_in(context):
             return environment
         self.capabilities(context.toolchain)

{lean_runtime-4.22.0 → lean_runtime-4.24.0}/lean_runtime/oci.py

@@ -28,7 +28,7 @@ from .bundles import (
     EnvironmentBundles,
     _capsule_config_object,
 )
-from .capsules import CapsuleManifest
+from .capsules import CAPSULE_MANIFEST, CapsuleManifest
 from .errors import (
     CredentialAcquisitionError,
     DownloadLimitExceeded,
@@ -62,6 +62,7 @@ from .store import (
     platform_compatibility,
     platform_record,
 )
+from .toolchains import immutable_toolchain_spelling
 
 _REPOSITORY = re.compile(r"[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)+")
 _BEARER_PARAMETER = re.compile(r'([a-zA-Z]+)="([^"]*)"')
@@ -887,6 +888,17 @@ class OCIEnvironmentCache:
         capsule = CapsuleManifest.from_dict(config["capsule"])
         if capsule.lock_id != lock.lock_id or capsule.toolchain != lock.toolchain:
             raise EnvironmentError("downloadable capsule does not match its lock")
+        # A capsule that lacks a requested root cannot satisfy this acquisition;
+        # silently projecting a partial closure would yield an environment that
+        # claims readiness while missing the modules the caller asked for.
+        available = {module.name for module in capsule.modules}
+        unavailable = tuple(root for root in roots if root not in available)
+        if unavailable:
+            raise DownloadUnavailable(
+                "downloadable capsule does not provide module(s): " + ", ".join(unavailable),
+                reason_code="capsule_roots_unavailable",
+                retryable=False,
+            )
         closure = capsule.closure(roots)
         module_names = tuple(module.name for module in closure)
         descriptors = {
@@ -1447,6 +1459,22 @@ class OCIEnvironmentPublisher:
     ) -> PublicationInfo:
         if profile != "check-capsule":
             raise ValueError("publication profile must be 'check-capsule'")
+        root = self.store.environment_path(environment_id)
+        try:
+            metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
+            lock = self.store.load_lock(str(metadata["lock_id"]))
+        except (OSError, KeyError, TypeError, json.JSONDecodeError) as exc:
+            raise EnvironmentError("publication input has invalid environment metadata") from exc
+        if (root / "workspace" / CAPSULE_MANIFEST).is_file():
+            raise EnvironmentError(
+                "publication input must be source-built; sparse acquired capsules cannot be "
+                "republished"
+            )
+        if not immutable_toolchain_spelling(lock.toolchain):
+            raise EnvironmentError(
+                f"refusing to publish mutable toolchain spelling {lock.toolchain!r}; "
+                "use an immutable release or dated nightly"
+            )
         self.check_access()
         with tempfile.TemporaryDirectory(prefix="lean-runtime-publish-") as temporary:
             temporary_root = Path(temporary)