lean-runtime 4.26.0__tar.gz → 4.30.0__tar.gz

{lean_runtime-4.26.0 → lean_runtime-4.30.0}/CHANGELOG.md

@@ -2,6 +2,76 @@
 
 ## Unreleased
 
+## 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 `⋯ <last activity> (Ns)` 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
+  lakefile. The workspace digest that keys header snapshots and provenance now
+  hashes `lakefile.toml`/`lakefile.lean`, `lean-toolchain`, `lake-manifest.json`,
+  and the `.lean` files under each declared target's module roots (the whole
+  tree, minus `.git` and `.lake`, when the lakefile is not declarative).
+  Previously every byte under the project root was read on each `check` and
+  `build`, so a lakefile above a data directory, a virtual environment, or an
+  unrelated monorepo made the first step of a check run for minutes with no
+  output. Digests change value once because of this.
+- Announce project fingerprinting as `project.fingerprint_started` and
+  `project.fingerprint_finished` events (phase `fingerprint`, with
+  `elapsed_ms`), so `--verbose` never goes silent between `check.started` and
+  the first Lake invocation.
+
 ## 4.26.0 - 2026-08-26
 
 - Stop `status` claiming a download is required for core-only files. A lock

{lean_runtime-4.26.0/lean_runtime.egg-info → lean_runtime-4.30.0}/PKG-INFO

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

{lean_runtime-4.26.0 → lean_runtime-4.30.0}/docs/reference/python-api.md

@@ -137,8 +137,11 @@ and lock identities, exact package commits and Git tree hashes, toolchain,
 platform, backend, policy, source digest, and start time.
 
 Mutable project results have no environment or lock identity. Their provenance
-instead records the canonical root, a workspace digest excluding `.git` and
-`.lake`, Lake configuration and manifest digests, and Git revision state.
+instead records the canonical root, a workspace digest of what Lake compiles
+(the lakefile, toolchain pin, manifest, and the `.lean` files under each
+declared target's module roots; the whole tree minus `.git` and `.lake` when the
+lakefile is not declarative), Lake configuration and manifest digests, and Git
+revision state.
 
 ## Work with Lake projects
 

lean_runtime-4.30.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.26.0 → lean_runtime-4.30.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.26.0 → lean_runtime-4.30.0}/lean_runtime/bundles.py

@@ -360,6 +360,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 +487,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:

{lean_runtime-4.26.0 → lean_runtime-4.30.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":

{lean_runtime-4.26.0 → lean_runtime-4.30.0}/lean_runtime/console.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import sys
+import threading
 import time
 from typing import Any, Literal, TextIO
 
@@ -16,6 +17,15 @@ _BAR_WIDTH = 20
 _TTY_REDRAW_SECONDS = 0.1
 _PLAIN_CHECKPOINT_PERCENT = 25
 _LARGE_CLOSURE_BYTES = 1024**3
+_HEARTBEAT_POLL_SECONDS = 0.25
+_PLAIN_HEARTBEAT_FIRST_SECONDS = 10.0
+_PLAIN_HEARTBEAT_REPEAT_SECONDS = 30.0
+_DETAIL_WIDTH = 60
+_OUTPUT_WIDTH = 100
+
+
+def _truncate(text: str, width: int) -> str:
+    return text if len(text) <= width else text[: width - 1] + "…"
 
 
 def select_mode(*, quiet: bool = False, stream: TextIO | None = None) -> RenderMode:
@@ -95,6 +105,7 @@ class ConsoleRenderer:
         verbose: bool = False,
         color: bool | None = None,
         clock: Any = time.monotonic,
+        heartbeat_seconds: float | None = None,
     ) -> None:
         self.stream = stream if stream is not None else sys.stderr
         self.mode: RenderMode = mode if mode is not None else select_mode(stream=self.stream)
@@ -107,26 +118,77 @@ class ConsoleRenderer:
         self._last_redraw: float | None = None
         self._next_checkpoint = _PLAIN_CHECKPOINT_PERCENT
         self._download_finished = False
+        self._count_key: tuple[str, int] | None = None
+        self._count_checkpoint = _PLAIN_CHECKPOINT_PERCENT
+        # Heartbeat: when events stop arriving mid-operation, keep showing the
+        # last known activity so a long silent phase never looks hung.
+        self._heartbeat_seconds = heartbeat_seconds
+        self._lock = threading.RLock()
+        self._last_event_at: float | None = None
+        self._last_message = ""
+        self._next_plain_heartbeat = _PLAIN_HEARTBEAT_FIRST_SECONDS
+        self._heartbeat_thread: threading.Thread | None = None
+        self._stop = threading.Event()
 
     def __call__(self, event: RuntimeEvent) -> None:
         if self.mode == "quiet":
             return
-        if self.verbose:
-            self._verbose_line(event)
-            return
-        handler = getattr(self, "_render_" + event.kind.replace(".", "_"), None)
-        if handler is not None:
-            handler(event)
+        with self._lock:
+            self._note_activity(event)
+            if self.verbose:
+                self._verbose_line(event)
+                return
+            handler = getattr(self, "_render_" + event.kind.replace(".", "_"), None)
+            if handler is not None:
+                handler(event)
 
     def note(self, message: str) -> None:
         """Print one renderer-owned status line."""
         if self.mode == "quiet":
             return
-        self._print(message)
+        with self._lock:
+            self._print(message)
 
     def close(self) -> None:
         """Terminate any in-place progress line before final output."""
-        self._end_progress_line()
+        self._stop.set()
+        thread = self._heartbeat_thread
+        if thread is not None and thread is not threading.current_thread():
+            thread.join(timeout=1)
+        with self._lock:
+            self._end_progress_line()
+
+    # -- heartbeat --------------------------------------------------------
+
+    def _note_activity(self, event: RuntimeEvent) -> None:
+        self._last_event_at = self._clock()
+        self._last_message = event.message
+        self._next_plain_heartbeat = _PLAIN_HEARTBEAT_FIRST_SECONDS
+        if (
+            self._heartbeat_seconds is not None
+            and self._heartbeat_thread is None
+            and not self._stop.is_set()
+        ):
+            self._heartbeat_thread = threading.Thread(
+                target=self._heartbeat_loop, name="lean-runtime-heartbeat", daemon=True
+            )
+            self._heartbeat_thread.start()
+
+    def _heartbeat_loop(self) -> None:
+        assert self._heartbeat_seconds is not None
+        while not self._stop.wait(_HEARTBEAT_POLL_SECONDS):
+            with self._lock:
+                if self._last_event_at is None or not self._last_message:
+                    continue
+                idle = self._clock() - self._last_event_at
+                if idle < self._heartbeat_seconds:
+                    continue
+                if self.mode == "tty":
+                    text = f"⋯ {_truncate(self._last_message, _OUTPUT_WIDTH)} ({int(idle)}s)"
+                    self._draw_line(text, self.style.dim(text))
+                elif idle >= self._next_plain_heartbeat:
+                    self._print(f"Still working: {self._last_message} ({int(idle)}s)")
+                    self._next_plain_heartbeat = idle + _PLAIN_HEARTBEAT_REPEAT_SECONDS
 
     # -- individual event renderings ------------------------------------
 
@@ -285,6 +347,67 @@ class ConsoleRenderer:
     def _render_project_workspace_lock_wait(self, event: RuntimeEvent) -> None:
         self._print(event.message)
 
+    # -- subprocess output and counted progress ---------------------------
+
+    def _render_process_progress(self, event: RuntimeEvent) -> None:
+        self._count_from(event, str(event.data.get("label") or "Working"), "detail")
+
+    def _render_process_output(self, event: RuntimeEvent) -> None:
+        if self.mode != "tty":
+            return
+        line = str(event.data.get("line") or "").strip()
+        if line:
+            text = _truncate(line, _OUTPUT_WIDTH)
+            self._draw_line(text, self.style.dim(text))
+
+    def _render_adopt_inspect_started(self, event: RuntimeEvent) -> None:
+        self._count_from(event, "Inspecting projects", "name")
+
+    def _render_adopt_identity_started(self, event: RuntimeEvent) -> None:
+        self._count_from(event, "Resolving dependency identities", "name")
+
+    def _render_project_detach_package_started(self, event: RuntimeEvent) -> None:
+        self._count_from(event, "Materializing packages", "package")
+
+    def _count_from(self, event: RuntimeEvent, label: str, detail_key: str) -> None:
+        current = event.data.get("current")
+        total = event.data.get("total")
+        if not isinstance(current, int) or not isinstance(total, int) or total <= 0:
+            return
+        self._render_count_progress(label, current, total, str(event.data.get(detail_key) or ""))
+
+    def _render_count_progress(self, label: str, current: int, total: int, detail: str) -> None:
+        current = min(current, total)
+        if self.mode == "tty":
+            now = self._clock()
+            if (
+                current < total
+                and self._last_redraw is not None
+                and now - self._last_redraw < _TTY_REDRAW_SECONDS
+            ):
+                return
+            self._last_redraw = now
+            filled = _BAR_WIDTH * current // total
+            bar = "█" * filled + "░" * (_BAR_WIDTH - filled)
+            suffix = f" · {_truncate(detail, _DETAIL_WIDTH)}" if detail else ""
+            plain = f"{label} [{bar}] {current}/{total}{suffix}"
+            styled = (
+                f"{label} [{self.style.cyan(bar)}] "
+                f"{self.style.bold(f'{current}/{total}')}{self.style.dim(suffix)}"
+            )
+            self._draw_line(plain, styled)
+            if current >= total:
+                self._end_progress_line()
+            return
+        key = (label, total)
+        if self._count_key != key:
+            self._count_key = key
+            self._count_checkpoint = _PLAIN_CHECKPOINT_PERCENT
+        percent = current * 100 // total
+        while self._count_checkpoint <= percent:
+            self._print(f"{label}: {self._count_checkpoint}% ({current}/{total})")
+            self._count_checkpoint += _PLAIN_CHECKPOINT_PERCENT
+
     # -- low-level output -----------------------------------------------
 
     def _verbose_line(self, event: RuntimeEvent) -> None:
@@ -325,6 +448,13 @@ class ConsoleRenderer:
         self.stream.flush()
         self._line_length = len(plain)
 
+    def _draw_line(self, plain: str, styled: str | None = None) -> None:
+        """Redraw the single in-place status line."""
+        padding = " " * max(0, self._line_length - len(plain))
+        self.stream.write("\r" + (styled if styled is not None else plain) + padding)
+        self.stream.flush()
+        self._line_length = len(plain)
+
     def _end_progress_line(self) -> None:
         if self._line_length:
             self.stream.write("\n")
@@ -332,6 +462,7 @@ class ConsoleRenderer:
             self._line_length = 0
 
     def _print(self, message: str) -> None:
-        self._end_progress_line()
-        self.stream.write(message + "\n")
-        self.stream.flush()
+        with self._lock:
+            self._end_progress_line()
+            self.stream.write(message + "\n")
+            self.stream.flush()

{lean_runtime-4.26.0 → lean_runtime-4.30.0}/lean_runtime/declaration_index.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import re
 import sqlite3
 from dataclasses import dataclass, replace
@@ -180,7 +181,7 @@ class DeclarationIndex:
 
     def _validate(self) -> None:
         try:
-            with self._connect() as connection:
+            with contextlib.closing(self._connect()) as connection:
                 version = int(connection.execute("PRAGMA user_version").fetchone()[0])
                 metadata = dict(connection.execute("SELECT key, value FROM meta"))
                 columns = {
@@ -226,7 +227,7 @@ class DeclarationIndex:
     @property
     def declaration_count(self) -> int:
         try:
-            with self._connect() as connection:
+            with contextlib.closing(self._connect()) as connection:
                 return int(connection.execute("SELECT count(*) FROM decl").fetchone()[0])
         except (sqlite3.Error, TypeError, ValueError) as exc:
             raise EnvironmentError("declaration shard count failed") from exc
@@ -235,7 +236,7 @@ class DeclarationIndex:
         if not valid_declaration_name(name):
             return None
         try:
-            with self._connect() as connection:
+            with contextlib.closing(self._connect()) as connection:
                 row = connection.execute(
                     "SELECT name, module, kind, weight FROM decl WHERE name = ?",
                     (name,),
@@ -248,7 +249,7 @@ class DeclarationIndex:
         if not valid_declaration_name(suffix) or not 1 <= limit <= 20:
             return ()
         try:
-            with self._connect() as connection:
+            with contextlib.closing(self._connect()) as connection:
                 rows = connection.execute(
                     """
                     SELECT d.name, d.module, d.kind, d.weight

{lean_runtime-4.26.0 → lean_runtime-4.30.0}/lean_runtime/locking.py

@@ -19,8 +19,9 @@ class FileLock:
     """One advisory cross-process lock.
 
     ``owner`` is a small JSON-serializable description of the acquiring
-    operation; on POSIX it is written into the lock file while the lock is
-    held so that waiters can attribute their wait. ``on_wait`` is invoked at
+    operation; it is published while the lock is held (POSIX: inside the lock
+    file, Windows: in a ``.owner`` sidecar, because a byte-locked file cannot
+    be read by waiters) so that waiters can attribute their wait. ``on_wait`` is invoked at
     most once, on first contention, with the current holder's description (or
     ``None`` when it cannot be read).
     """
@@ -44,19 +45,37 @@ class FileLock:
     def holder(self) -> dict[str, Any] | None:
         """Best-effort description of the current lock holder."""
         try:
-            value = json.loads(self.path.read_text(encoding="utf-8"))
+            value = json.loads(self._owner_source().read_text(encoding="utf-8"))
         except (OSError, UnicodeError, json.JSONDecodeError):
             return None
         return value if isinstance(value, dict) else None
 
+    def _owner_source(self) -> Path:
+        """Where the holder's description lives.
+
+        POSIX writes it into the lock file itself. Windows mandatory byte locks
+        make a locked file unreadable to waiters, so the description lives in a
+        sidecar beside the lock instead.
+        """
+        if os.name == "nt":
+            return self.path.with_name(self.path.name + ".owner")
+        return self.path
+
     def _write_owner(self, handle: BinaryIO) -> None:
-        if self.owner is None or os.name == "nt":
+        if self.owner is None:
             return
         try:
-            handle.seek(0)
-            handle.truncate()
-            handle.write(json.dumps({"pid": os.getpid(), **self.owner}).encode("utf-8"))
-            handle.flush()
+            payload = json.dumps({"pid": os.getpid(), **self.owner}).encode("utf-8")
+            if os.name == "nt":
+                sidecar = self._owner_source()
+                temporary = sidecar.with_name(f"{sidecar.name}.{os.getpid()}.tmp")
+                temporary.write_bytes(payload)
+                temporary.replace(sidecar)
+            else:
+                handle.seek(0)
+                handle.truncate()
+                handle.write(payload)
+                handle.flush()
             self._owner_written = True
         except (OSError, TypeError, ValueError):
             self._owner_written = False
@@ -119,9 +138,12 @@ class FileLock:
             return
         if self._owner_written:
             with contextlib.suppress(OSError):
-                handle.seek(0)
-                handle.truncate()
-                handle.flush()
+                if os.name == "nt":
+                    self._owner_source().unlink()
+                else:
+                    handle.seek(0)
+                    handle.truncate()
+                    handle.flush()
             self._owner_written = False
         if os.name == "nt":
             import msvcrt

lean_runtime-4.30.0/lean_runtime/package_ids.py

@@ -0,0 +1,42 @@
+"""Names of managed package directories in the shared project store.
+
+A package directory is content-addressed by its identity marker. The original
+scheme named directories ``project_package_<64 hex>``; that 80-character name
+pushed Mathlib's deepest build outputs past Windows' 260-character path limit
+(``…\\project_package_<64>\\.lake\\build\\lib\\lean\\Mathlib\\…\\Isometric.olean.server``).
+New directories therefore use ``pkg_<32 hex>``, the same digest truncated to
+128 bits. Legacy directories stay valid and reusable.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from .serialization import sha256_id
+
+PACKAGE_ID_PATTERN = re.compile(r"(?:project_package_[0-9a-f]{64}|pkg_[0-9a-f]{32})\Z")
+_DIRECTORY_GLOBS = ("project_package_*", "pkg_*")
+
+
+def package_directory_id(identity: dict[str, Any]) -> str:
+    """Name the store directory for one package identity marker."""
+    digest = sha256_id("project_package", identity).removeprefix("project_package_")
+    return f"pkg_{digest[:32]}"
+
+
+def package_id_matches(identity: dict[str, Any], package_id: str) -> bool:
+    """Whether ``package_id`` names ``identity`` under either naming scheme."""
+    return package_id in {sha256_id("project_package", identity), package_directory_id(identity)}
+
+
+def is_package_id(value: str) -> bool:
+    return PACKAGE_ID_PATTERN.fullmatch(value) is not None
+
+
+def package_directories(root: Path) -> list[Path]:
+    """Managed package directories under ``root`` in both naming schemes, sorted."""
+    return sorted(
+        path for pattern in _DIRECTORY_GLOBS for path in root.glob(pattern) if path.is_dir()
+    )