lean-runtime 4.27.0__tar.gz → 4.33.0__tar.gz

{lean_runtime-4.27.0 → lean_runtime-4.33.0}/CHANGELOG.md

@@ -2,6 +2,83 @@
 
 ## Unreleased
 
+## 4.33.0 - 2026-08-27
+
+- Cover the remaining silent phases with progress. Elan bootstrap and
+  `elan toolchain install`, and the `lake init`/`lake update` behind `new`, now
+  stream their output as `process.progress`/`process.output` like every other
+  subprocess. Long pure-Python loops report counted progress that renders as a
+  bar: `verification.inventory` (hashing build artifacts in `verify`),
+  `bundle.tree_inventory` (`env export`/`import`), `source.snapshot_digest`
+  (source fingerprints, including path dependencies during `adopt`), and
+  `capsule.import_parse`. The publish preflight fetch
+  (`publish.remote_probe_started`) and the Lake configuration read behind
+  project-wide `check` (`project.config_translate_started`) announce
+  themselves. Any event carrying `current`/`total` and a `label` now renders as
+  a counted bar without a dedicated console handler, and deep helpers reach
+  the active runtime's emitter through `lean_runtime.events.current()`.
+- Re-running `adopt` over a tree no longer re-probes every already attached
+  project (a Lake graph load each, up to two minutes for Mathlib); the plan
+  already reports them as attached and `verify` re-checks links. Attachment
+  now announces `adopt.attach_started` per project, rendered as
+  `Attaching projects [bar] i/n`, and the pre-swap Lake graph probe streams its
+  output like every other Lake invocation instead of running silently.
+
+## 4.30.0 - 2026-08-26
+
+- Attach shared dependencies on Windows without administrator rights. Creating
+  a symbolic link needs `SeCreateSymbolicLinkPrivilege` (administrators or
+  Developer Mode), so `adopt` and `project attach` failed with
+  `WinError 1314: A required privilege is not held by the client` on a normal
+  account, and the pre-attach probe never caught it. When symlink creation is
+  denied, the package link is now created as a directory junction, which any
+  user may create and which Lake and Git traverse identically. Every place
+  that recognizes an attached package as a link (`status`, `verify`,
+  `unshare`, adoption planning, rollback, source fingerprinting) now
+  recognizes junctions too.
+- Size local dependency checkouts during `adopt` without descending into
+  attached links, using one directory scan per level instead of `rglob`.
+- Show progress while subprocesses run. Lake's `[n/m]` build steps now stream
+  from `check`, `build`, and artifact hydration as `process.progress` events
+  (rate-limited to ten per second), rendered on a terminal as one in-place bar
+  (`lake [████░░░░] 3300/8318 · Building Mathlib.Foo`) and in logs as 25%
+  checkpoints; every other output line becomes a throttled `process.output`
+  heartbeat shown in place on a terminal, so `lake exe cache get` is no longer
+  silent. Third-party backends that do not accept the new optional `on_output`
+  callback keep working unchanged.
+- Announce counted phases that used to be silent: `adopt.inspect_started` and
+  `adopt.identity_started` for each project during adoption planning, and
+  `project.detach.package_started` for each package `unshare` materializes; all
+  carry `current`/`total` and render as the same counted bar.
+- Keep the terminal alive during any silent stretch: when no event has arrived
+  for two seconds the console shows `⋯ no new events for Ns · last: <activity>`
+  in place; plain logs print `Still working (…)` after ten seconds and then
+  every thirty.
+- Name new shared package directories `pkg_<32 hex>` instead of
+  `project_package_<64 hex>`. The 80-character name pushed Mathlib's deepest
+  build outputs past Windows' 260-character path limit, so an adopted Mathlib
+  project could hydrate its cache but never finish `build`
+  (`failed to create file '…\Isometric.olean.server'`). The digest is the same
+  identity truncated to 128 bits; existing `project_package_*` directories stay
+  valid and reusable. To move already adopted projects onto short paths,
+  `lean-runtime project unshare` each of them, delete the legacy
+  `project-packages/project_package_*` directories (nothing references them once
+  every project is unshared; `clean` does not yet reclaim them), and
+  `lean-runtime adopt` again.
+- Windows correctness fixes surfaced by running the suite on Windows:
+  compact source snapshots stage under a shorter directory name so Git's
+  shallow-clone metadata stays below `MAX_PATH` (`'$GIT_DIR' too big`);
+  `lean-runtime run` rewrites a container backend's POSIX staged path back to
+  the user's file on Windows hosts; lock waiters learn the holding operation
+  through a `.owner` sidecar (a byte-locked file cannot be read on Windows);
+  declaration shards close their SQLite connection before publication so the
+  rename succeeds; `storage` deduplicates hard links via `os.stat()` because
+  `DirEntry.stat()` reports no inode on Windows; `publish` accepts a
+  drive-letter origin path (`C:\...`) instead of treating `C` as a URL scheme;
+  bundle import accepts CRLF working files whose LF-normalized blob is the
+  recorded object (`core.autocrlf`); and storage cleanup clamps negative file
+  ages from filesystem timestamp granularity.
+
 ## 4.27.0 - 2026-08-26
 
 - Fingerprint a project by what Lake compiles, not by everything beside the

{lean_runtime-4.27.0/lean_runtime.egg-info → lean_runtime-4.33.0}/PKG-INFO

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

lean_runtime-4.33.0/lean_runtime/_paths.py

@@ -0,0 +1,87 @@
+"""Internal cross-platform filesystem operations."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+import time
+from collections.abc import Callable
+from pathlib import Path
+from types import TracebackType
+from typing import Any, cast
+
+_WINDOWS_MOUNT_POINT_REPARSE_TAG = 0xA0000003
+
+
+def _retry_writable(
+    function: Callable[..., Any],
+    path: str,
+    _error: tuple[type[BaseException], BaseException, TracebackType | None],
+) -> None:
+    """Clear Git-for-Windows read-only attributes and retry one removal."""
+
+    os.chmod(path, stat.S_IWRITE)
+    function(path)
+
+
+def is_link(path: Path) -> bool:
+    """Whether ``path`` is a symbolic link or a Windows directory junction.
+
+    Shared package directories are attached as links. Python reports a
+    junction as a plain directory (``is_symlink()`` is false), so every place
+    that asks "is this an attached link?" must go through this helper.
+    """
+
+    if path.is_symlink():
+        return True
+    if os.name != "nt":
+        return False
+    try:
+        status = os.lstat(path)
+    except OSError:
+        return False
+    attributes = getattr(status, "st_file_attributes", 0)
+    reparse_tag = getattr(status, "st_reparse_tag", 0)
+    return bool(attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT) and (
+        reparse_tag == _WINDOWS_MOUNT_POINT_REPARSE_TAG
+    )
+
+
+def link_directory(target: Path, link: Path) -> None:
+    """Attach ``link`` to the directory ``target`` without requiring privileges.
+
+    A symbolic link is preferred everywhere. Windows only grants symlink
+    creation to administrators or Developer Mode users
+    (``ERROR_PRIVILEGE_NOT_HELD``, 1314); in that case a directory junction,
+    which any user may create and which Lake and Git traverse identically, is
+    used instead.
+    """
+
+    try:
+        os.symlink(target, link, target_is_directory=True)
+    except OSError as exc:
+        if os.name != "nt" or getattr(exc, "winerror", None) != 1314:
+            raise
+        import _winapi
+
+        # These members exist only in the Windows runtime/typeshed surface.
+        # Resolve the API dynamically so strict checking on macOS/Linux still
+        # validates this module instead of rejecting the platform-only member.
+        create_junction = cast(Callable[[str, str], None], vars(_winapi)["CreateJunction"])
+        create_junction(str(target.resolve()), str(link))
+
+
+def remove_tree(path: Path) -> None:
+    """Remove a tree containing Git packs, tolerating transient Windows locks."""
+
+    for attempt in range(4):
+        try:
+            shutil.rmtree(path, onerror=_retry_writable)
+            return
+        except PermissionError:
+            if not path.exists():
+                return
+            if attempt == 3:
+                raise
+            time.sleep(0.05 * (2**attempt))

{lean_runtime-4.27.0 → lean_runtime-4.33.0}/lean_runtime/backends.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+import re
 import signal
 import subprocess
 import threading
@@ -83,14 +84,39 @@ class _OutputBudget:
             return chunk[:size]
 
 
-def _drain(stream: BinaryIO, budget: _OutputBudget, chunks: list[bytes]) -> None:
+_LINE_BREAK = re.compile(rb"\r\n|\r|\n")
+
+
+def _drain(
+    stream: BinaryIO,
+    budget: _OutputBudget,
+    chunks: list[bytes],
+    on_output: Callable[[str], None] | None = None,
+) -> None:
+    pending = b""
     while True:
         chunk = stream.read(65_536)
         if not chunk:
-            return
+            break
         kept = budget.take(chunk)
         if kept:
             chunks.append(kept)
+        if on_output is None:
+            continue
+        # Progress bars redraw with bare carriage returns, so treat those as lines too.
+        parts = _LINE_BREAK.split(pending + chunk)
+        pending = parts.pop()
+        for part in parts:
+            _observe(on_output, part)
+    if on_output is not None and pending:
+        _observe(on_output, pending)
+
+
+def _observe(on_output: Callable[[str], None], line: bytes) -> None:
+    try:
+        on_output(line.decode("utf-8", errors="replace"))
+    except Exception:  # noqa: BLE001 - an observer must never break execution
+        return
 
 
 class _TranscriptReader:
@@ -294,6 +320,7 @@ class LocalBackend:
         environment: Mapping[str, str],
         policy: ExecutionPolicy,
         cancel: threading.Event | None = None,
+        on_output: Callable[[str], None] | None = None,
     ) -> BackendResult:
         enforced, preexec, creationflags = self._process_options(policy)
 
@@ -313,8 +340,12 @@ class LocalBackend:
         stdout_chunks: list[bytes] = []
         stderr_chunks: list[bytes] = []
         readers = [
-            threading.Thread(target=_drain, args=(process.stdout, budget, stdout_chunks)),
-            threading.Thread(target=_drain, args=(process.stderr, budget, stderr_chunks)),
+            threading.Thread(
+                target=_drain, args=(process.stdout, budget, stdout_chunks, on_output)
+            ),
+            threading.Thread(
+                target=_drain, args=(process.stderr, budget, stderr_chunks, on_output)
+            ),
         ]
         for reader in readers:
             reader.start()

{lean_runtime-4.27.0 → lean_runtime-4.33.0}/lean_runtime/bundles.py

@@ -13,10 +13,11 @@ import tarfile
 import tempfile
 import uuid
 from collections.abc import Iterable, Mapping, Sequence
+from contextlib import nullcontext
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
-from typing import Any
+from typing import Any, Protocol
 
 import zstandard
 
@@ -33,7 +34,7 @@ from .capsules import (
     setup_artifact_groups,
 )
 from .errors import EnvironmentError
-from .events import EventEmitter
+from .events import EventEmitter, current
 from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock, LockedPackage
 from .locking import FileLock
@@ -61,6 +62,7 @@ from .packs import (
     unpack_frame,
 )
 from .policies import ExecutionPolicy
+from .progress import CountedProgress
 from .serialization import canonical_json_bytes, write_json_atomic
 from .store import (
     EnvironmentStore,
@@ -81,6 +83,53 @@ SOURCE_TREE_INVENTORY = ".lean-runtime-source-tree.json"
 MAX_CAPSULE_CONFIG_BYTES = 64 * 1024**2
 
 
+class _BinaryReader(Protocol):
+    def read(self, size: int = -1) -> bytes: ...
+
+    def readinto(self, buffer: Any) -> int | None: ...
+
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+
+    def tell(self) -> int: ...
+
+
+class _ProgressReader:
+    """Report bytes after a consumer has actually read them."""
+
+    def __init__(
+        self, handle: _BinaryReader, progress: CountedProgress, *, offset: int = 0
+    ) -> None:
+        self._handle = handle
+        self._progress = progress
+        self._offset = offset
+        self._furthest = offset
+
+    def _report(self) -> None:
+        position = self._offset + self._handle.tell()
+        if position > self._furthest:
+            self._furthest = position
+            self._progress.advance(to=position)
+
+    def read(self, size: int = -1) -> bytes:
+        data = self._handle.read(size)
+        self._report()
+        return data
+
+    def readinto(self, buffer: Any) -> int:
+        count = self._handle.readinto(buffer)
+        self._report()
+        return count if count is not None else 0
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        return self._handle.seek(offset, whence)
+
+    def tell(self) -> int:
+        return self._handle.tell()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._handle, name)
+
+
 @dataclass(frozen=True, slots=True)
 class PortableCopyInfo:
     environment_id: str
@@ -130,8 +179,27 @@ def _tree_entries(
     excluded_names: frozenset[str] = frozenset(),
     omit_volatile_build_metadata: bool = False,
 ) -> Iterable[tuple[Path, str]]:
-    for path in sorted(root.rglob("*"), key=lambda value: value.relative_to(root).as_posix()):
+    scan = CountedProgress(
+        current().emit,
+        "bundle.tree_scan",
+        f"Scanning {root.name}",
+        1,
+        phase="bundle",
+    )
+    scan.start()
+    paths = sorted(root.rglob("*"), key=lambda value: value.relative_to(root).as_posix())
+    scan.advance(f"{len(paths)} entries")
+    progress = CountedProgress(
+        current().emit,
+        "bundle.tree_inventory",
+        f"Inventorying {root.name}",
+        len(paths),
+        phase="bundle",
+    )
+    progress.start()
+    for path in paths:
         if excluded is not None and (path == excluded or excluded in path.parents):
+            progress.advance(path.relative_to(root).as_posix())
             continue
         relative = path.relative_to(root)
         if relative.parts and relative.parts[0] in excluded_names:
@@ -145,8 +213,10 @@ def _tree_entries(
                 or relative.name.endswith(".rsp")
             )
         ):
+            progress.advance(relative.as_posix())
             continue
         yield path, relative.as_posix()
+        progress.advance(relative.as_posix())
 
 
 def _write_tar_gzip(
@@ -219,6 +289,18 @@ def _oci_archive(entries: dict[str, bytes]) -> bytes:
 
 
 def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
+    ordered = sorted(entries.items())
+    total = sum(path.stat().st_size for _name, path in ordered)
+    progress = CountedProgress(
+        current().emit,
+        "bundle.archive_write",
+        "Writing portable archive",
+        total,
+        phase="bundle",
+        unit="bytes",
+    )
+    progress.start()
+    written = 0
     with (
         output.open("wb") as raw_output,
         gzip.GzipFile(
@@ -226,11 +308,13 @@ def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
         ) as compressed,
         tarfile.open(fileobj=compressed, mode="w|", format=tarfile.PAX_FORMAT) as archive,
     ):
-        for name, path in sorted(entries.items()):
+        for name, path in ordered:
             info = _normalized_info(name, mode=0o644)
             info.size = path.stat().st_size
             with path.open("rb") as handle:
-                archive.addfile(info, handle)
+                archive.addfile(info, _ProgressReader(handle, progress, offset=written))
+            written += info.size
+            progress.advance(name, to=written)
 
 
 def _safe_name(name: str) -> PurePosixPath:
@@ -315,16 +399,32 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
     if destination.is_symlink():
         raise EnvironmentError("bundle extraction destination must not be a symlink")
     destination.mkdir(parents=True, exist_ok=True)
+    progress: CountedProgress | None = None
+    raw_handle: Any = None
     try:
         if isinstance(data, Path):
-            archive = tarfile.open(data, mode="r:gz")  # noqa: SIM115
+            raw_handle = data.open("rb")
+            progress = CountedProgress(
+                current().emit,
+                "bundle.layer_extract",
+                f"Extracting {destination.name}",
+                data.stat().st_size,
+                phase="bundle",
+                unit="bytes",
+            )
+            progress.start()
+            archive = tarfile.open(  # noqa: SIM115
+                fileobj=_ProgressReader(raw_handle, progress), mode="r:gz"
+            )
         else:
             archive = tarfile.open(  # noqa: SIM115
                 fileobj=io.BytesIO(data), mode="r:gz"
             )
     except (tarfile.TarError, OSError) as exc:
+        if raw_handle is not None:
+            raw_handle.close()
         raise EnvironmentError("bundle layer is not a valid gzip tar archive") from exc
-    with archive:
+    with archive, raw_handle if raw_handle is not None else nullcontext():
         for member in archive:
             count += 1
             total += member.size
@@ -353,6 +453,8 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
                 target.symlink_to(member.linkname)
             else:
                 raise EnvironmentError(f"unsupported bundle member: {member.name!r}")
+    if progress is not None:
+        progress.advance(to=progress.total)
 
 
 def _git_object_id(kind: str, data: bytes) -> str:
@@ -360,6 +462,18 @@ def _git_object_id(kind: str, data: bytes) -> str:
     return hashlib.sha1(framed, usedforsecurity=False).hexdigest()  # noqa: S324
 
 
+def _matches_normalized(data: bytes, object_id: str) -> bool:
+    """Accept a CRLF working file whose LF-normalized blob is the recorded one.
+
+    Git with ``core.autocrlf`` (the Git for Windows default) stores text blobs
+    with LF endings while checking them out with CRLF, so the on-disk bytes of
+    an untouched file legitimately hash differently from its recorded object.
+    """
+    if b"\r\n" not in data:
+        return False
+    return _git_object_id("blob", data.replace(b"\r\n", b"\n")) == object_id
+
+
 def _source_tree_inventory(root: Path, package: LockedPackage) -> bytes:
     process = subprocess.run(
         git_command("-C", str(root), "ls-tree", "-rz", "--full-tree", "HEAD"),
@@ -475,7 +589,7 @@ def _verify_source_tree_inventory(root: Path, package: LockedPackage, path: Path
             if executable != (mode == "100755"):
                 raise EnvironmentError(f"bundled package source mode mismatch: {package.name}")
             data = source.read_bytes()
-        if _git_object_id("blob", data) != object_id:
+        if _git_object_id("blob", data) != object_id and not _matches_normalized(data, object_id):
             raise EnvironmentError(f"bundled package source mismatch: {package.name}")
         entries.append(entry)
     if _inventory_tree_id(entries) != package.tree_hash:
@@ -1100,11 +1214,26 @@ class EnvironmentBundles:
         entries: dict[str, Path] = {}
         total = 0
         count = 0
+        byte_progress = CountedProgress(
+            current().emit,
+            "bundle.archive_extract",
+            f"Reading {bundle.name}",
+            bundle.stat().st_size,
+            phase="bundle",
+            unit="bytes",
+        )
+        byte_progress.start()
+        raw_handle: Any = None
         try:
-            archive = tarfile.open(bundle, mode="r:gz")  # noqa: SIM115
+            raw_handle = bundle.open("rb")
+            archive = tarfile.open(  # noqa: SIM115
+                fileobj=_ProgressReader(raw_handle, byte_progress), mode="r:gz"
+            )
         except (tarfile.TarError, OSError) as exc:
+            if raw_handle is not None:
+                raw_handle.close()
             raise EnvironmentError(f"could not read OCI bundle: {bundle}") from exc
-        with archive:
+        with archive, raw_handle:
             for member in archive:
                 count += 1
                 if count > MAX_FILES:
@@ -1124,6 +1253,7 @@ class EnvironmentBundles:
                 with path.open("wb") as output:
                     shutil.copyfileobj(source, output)
                 entries[member.name] = path
+        byte_progress.advance(to=byte_progress.total)
         return entries
 
     def _import_capsule_layout(

{lean_runtime-4.27.0 → lean_runtime-4.33.0}/lean_runtime/capsules.py

@@ -21,8 +21,10 @@ from pathlib import Path, PurePosixPath
 from typing import Any, Literal
 
 from .errors import EnvironmentError
+from .events import current
 from .import_syntax import IMPORT_STATEMENT
 from .lockfiles import EnvironmentLock
+from .progress import CountedProgress
 from .serialization import canonical_json_bytes, write_json_atomic
 
 CAPSULE_SCHEMA = "lean-runtime-check-capsule/1"
@@ -253,6 +255,14 @@ def parse_import_headers(
     with tempfile.TemporaryDirectory(prefix="lean-runtime-imports-") as raw:
         helper = Path(raw) / "ParseImports.lean"
         helper.write_text(IMPORT_PARSER_SOURCE, encoding="utf-8")
+        progress = CountedProgress(
+            current().emit,
+            "capsule.import_parse",
+            "Parsing imports",
+            len(source_paths),
+            phase="capsule",
+        )
+        progress.start()
         for offset in range(0, len(source_paths), batch_size):
             batch = list(source_paths[offset : offset + batch_size])
             process = subprocess.run(
@@ -286,6 +296,7 @@ def parse_import_headers(
                     if isinstance(item, dict) and isinstance(item.get("module"), str)
                 }
                 result[path] = tuple(sorted(names))
+            progress.advance(to=min(offset + len(batch), len(source_paths)))
     return result
 
 
@@ -369,16 +380,34 @@ def build_manifest(
     complete_modules: frozenset[str] | None = None,
 ) -> CapsuleManifest:
     """Inventory retained module artifacts beneath package build roots."""
+    scan = CountedProgress(
+        current().emit,
+        "capsule.artifact_scan",
+        "Scanning capsule artifacts",
+        1,
+        phase="capsule",
+    )
+    scan.start()
+    paths = [
+        (package, root, path)
+        for package, root in sorted(build_roots.items())
+        if root.is_dir()
+        for path in sorted(root.rglob("*"))
+        if path.is_file()
+    ]
+    scan.advance(f"{len(paths)} files")
+    progress = CountedProgress(
+        current().emit,
+        "capsule.artifact_inventory",
+        "Hashing capsule artifacts",
+        len(paths),
+        phase="capsule",
+    )
+    progress.start()
     modules: dict[str, tuple[str, list[CapsuleArtifact]]] = {}
-    for package, root in sorted(build_roots.items()):
-        if not root.is_dir():
-            continue
-        for path in sorted(root.rglob("*")):
-            if not path.is_file():
-                continue
-            module = module_from_artifact(path.relative_to(root))
-            if module is None:
-                continue
+    for package, root, path in paths:
+        module = module_from_artifact(path.relative_to(root))
+        if module is not None:
             relative = path.relative_to(workspace).as_posix()
             capability = artifact_capability(path)
             artifact = CapsuleArtifact(
@@ -390,6 +419,7 @@ def build_manifest(
                     f"capsule module {module} is provided by both {existing[0]} and {package}"
                 )
             modules.setdefault(module, (package, []))[1].append(artifact)
+        progress.advance(path.relative_to(workspace).as_posix())
     known_complete = frozenset(imports) if complete_modules is None else complete_modules
     records = tuple(
         CapsuleModule(
@@ -436,6 +466,14 @@ def inventory_workspace(
 ) -> CapsuleManifest:
     """Build an exact capsule inventory from a verified full workspace."""
     source_roots, build_roots = _package_directories(workspace, lock)
+    discovery = CountedProgress(
+        current().emit,
+        "capsule.module_discovery",
+        "Discovering capsule modules",
+        len(build_roots) + len(source_roots),
+        phase="capsule",
+    )
+    discovery.start()
     modules_by_package: dict[str, set[str]] = {}
     for package, root in build_roots.items():
         modules_by_package[package] = {
@@ -443,11 +481,13 @@ def inventory_workspace(
             for path in root.rglob("*.olean")
             if (module := module_from_artifact(path.relative_to(root))) is not None
         }
+        discovery.advance(package)
 
     source_modules: dict[Path, str] = {}
     claimed: dict[str, tuple[int, Path]] = {}
     for package, root in source_roots.items():
         if not root.is_dir():
+            discovery.advance(package)
             continue
         available = modules_by_package[package]
         for path in sorted(root.rglob("*.lean")):
@@ -473,6 +513,7 @@ def inventory_workspace(
                 source_modules.pop(previous[1], None)
             claimed[module] = (stripped, path)
             source_modules[path] = module
+        discovery.advance(package)
 
     parsed = parse_import_headers(lean_command, tuple(source_modules))
     imports = {source_modules[path]: names for path, names in parsed.items()}

{lean_runtime-4.27.0 → lean_runtime-4.33.0}/lean_runtime/cli.py

@@ -1924,6 +1924,7 @@ def main(argv: list[str] | None = None) -> int:
     renderer = ConsoleRenderer(
         mode="quiet" if args.quiet or getattr(args, "json", False) else None,
         verbose=args.verbose,
+        heartbeat_seconds=2.0,
     )
     try:
         if args.command == "completion":
@@ -1969,9 +1970,9 @@ def main(argv: list[str] | None = None) -> int:
             )
             if declined is not None:
                 return declined
-            di_publication = OCIDeclarationIndexPublisher(di_repository).publish(
-                tuple(di_item.source for di_item in built.shards), lock_id=lock.lock_id
-            )
+            di_publication = OCIDeclarationIndexPublisher(
+                di_repository, events=runtime.events
+            ).publish(tuple(di_item.source for di_item in built.shards), lock_id=lock.lock_id)
             if args.sign:
                 CosignVerifier(executable=runtime.verification_executable).sign(
                     di_repository, di_publication.manifest_digest