lean-runtime 2.6.1__tar.gz → 2.7.0__tar.gz

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## Unreleased
 
+## 2.7.0 - 2026-08-14
+
+- Keep newly initialized project roots narrow: the generated root imports its
+  local `Basic` module without redundantly importing the all-Mathlib umbrella,
+  and the completion hint points to the fast first-file check.
+- Render stdin diagnostics as `<stdin>` in the CLI instead of exposing the
+  disposable `.lake/lean-runtime` staging path.
+- Add fileless `lean-runtime check` and `ProjectEnvironment.check_all()` to
+  check every declared local library through Lake's `leanArts` facets, retaining
+  correct intra-project dependency ordering without building executables.
+- Integrate an ABI- and toolchain-isolated root-project Lake artifact cache for
+  projects created by `init`. Capability support is probed and persisted rather
+  than version-gated; dependencies remain in the verified shared workspace.
+- Keep remote Lake mappings fail-closed until artifacts have a verified SHA-256
+  inventory and lazy restoration participates in acquisition planning and
+  download limits.
+
+## 2.6.2 - 2026-08-14
+
+- Keep an existing initialization target's directory inode alive, so running
+  `lean-runtime init .` no longer strands the invoking shell in an unlinked
+  working directory. Fully prepared staged children are published with rollback
+  while Git metadata, custom agent guidance, and index state remain in place.
+- Make attachment plans distinguish checkout bytes removed, compatible shared
+  bytes already available, new shared bytes required, and estimated machine
+  recovery. Exact managed packages now bypass redundant source resolution when
+  their toolchain, platform, revision, and effective dependency closure match.
+- Emit package-by-package shared-workspace resolution, reuse, and import events,
+  and add `lean-runtime --version`.
+
 ## 2.6.1 - 2026-08-14
 
 - Allow `lean-runtime init .` at an otherwise empty Git repository root while

{lean_runtime-2.6.1/lean_runtime.egg-info → lean_runtime-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.6.1
+Version: 2.7.0
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -188,6 +188,8 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 
@@ -213,6 +215,8 @@ For a new project, the target may be absent, empty, or an otherwise empty Git
 repository root; existing Git identity and index state are preserved. A custom
 `AGENTS.md` is also allowed and retained. Other existing contents are rejected
 before acquisition rather than overwritten.
+An existing target directory remains the same live directory, so `init .` does
+not invalidate the invoking shell's working directory.
 When the directory spelling is not the intended Lean module capitalization,
 set it explicitly, for example `lean-runtime init . --name IntegralFramework`.
 

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/README.md

@@ -152,6 +152,8 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 
@@ -177,6 +179,8 @@ For a new project, the target may be absent, empty, or an otherwise empty Git
 repository root; existing Git identity and index state are preserved. A custom
 `AGENTS.md` is also allowed and retained. Other existing contents are rejected
 before acquisition rather than overwritten.
+An existing target directory remains the same live directory, so `init .` does
+not invalidate the invoking shell's working directory.
 When the directory spelling is not the intended Lean module capitalization,
 set it explicitly, for example `lean-runtime init . --name IntegralFramework`.
 

lean_runtime-2.7.0/compatibility/README.md

@@ -0,0 +1,14 @@
+# Compatibility profiles
+
+Profiles exercise published environments rather than mocking Lake. The Mathlib
+4.32.2 and 4.33.0 profiles independently acquire their bundled exact catalog
+locks and import the public `Mathlib` root. Transitive packages remain attested
+in the lock but are not advertised as independent catalog roots.
+
+```bash
+python scripts/run_compatibility.py compatibility/mathlib-4.32.2.json
+python scripts/run_compatibility.py compatibility/mathlib-4.33.0.json
+```
+
+The first run downloads the verified sparse environment. Later runs reuse its
+content-addressed artifacts and published workspace.

lean_runtime-2.7.0/compatibility/lake-artifact-cache-4.33.0.json

@@ -0,0 +1,32 @@
+{
+  "schema": "lean-runtime.lake-cache-contract/v1",
+  "toolchain": "leanprover/lean4:v4.33.0",
+  "lake_version_observed": "5.0.0-src+d8b1897",
+  "capability_probes": {
+    "build_mappings": ["lake", "build", "--help"],
+    "cache_add": ["lake", "cache", "add", "--help"]
+  },
+  "configuration": {
+    "cache_root": "LAKE_CACHE_DIR",
+    "workspace_cache": "LAKE_ARTIFACT_CACHE",
+    "restore": "LAKE_RESTORE_ARTIFACTS",
+    "root_package_opt_in": "enableArtifactCache = true"
+  },
+  "observable_hit_signals": [
+    "found artifact in cache",
+    "restored artifact from cache",
+    "downloaded artifact"
+  ],
+  "experiment": {
+    "broad_cache_bytes": 6500000000,
+    "explicit_library_jobs": 8708,
+    "root_only_cache_bytes": 396000,
+    "root_restore_seconds": 5.17,
+    "dependency_heavy_fixture": "mathlib consumer",
+    "focused_lake_env_lean_uses_artifact_cache": false
+  },
+  "security": {
+    "lake_remote_hash_cryptographic": false,
+    "remote_registration": "disabled_pending_attested_sha256_inventory"
+  }
+}

lean_runtime-2.7.0/compatibility/mathlib-4.32.2.json

@@ -0,0 +1,8 @@
+{
+  "name": "mathlib-4.32.2",
+  "reference": "mathlib@v4.32.2",
+  "spec": "mathlib-4.32.2.toml",
+  "imports": [
+    "Mathlib"
+  ]
+}

lean_runtime-2.7.0/compatibility/mathlib-4.33.0.json

@@ -0,0 +1,8 @@
+{
+  "name": "mathlib-4.33.0",
+  "reference": "mathlib@v4.33.0",
+  "spec": "mathlib-4.33.0.toml",
+  "imports": [
+    "Mathlib"
+  ]
+}

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/docs/architecture.md

@@ -39,6 +39,22 @@ published environment identity includes platform and build-profile inputs.
 Each execution attempt has a unique history identity. A separate stable request
 digest includes the environment, input digest, operation, and requested policy.
 
+## Internal ownership
+
+The high-level `Runtime` is a compatibility facade rather than the owner of
+every workflow. Environment resolution and materialization remain in their
+dedicated managers. Mutable local-project checks and builds pass through
+`ProjectExecutor`, which owns Lake command selection and shared-workspace build
+locking. This is the integration boundary for Lake facilities such as its
+artifact cache; `Runtime` should not grow a second project build planner.
+
+Environment capsules, slim toolchains, and ready-to-run programs have distinct
+payload schemas. Their common OCI descriptor, digest, JSON, and platform
+selection contract lives in `oci_protocol`. Payload implementations must not
+import another payload implementation's private protocol helpers. Existing
+legacy bundle readers remain supported, but new transport behavior belongs to
+the shared protocol or the current sparse capsule path.
+
 ## Public identities
 
 Two lifecycle identities are central to the ordinary API:

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/docs/cli.md

@@ -176,11 +176,18 @@ recursive mode inventories a project tree, reports blockers and estimated disk
 recovery, and adopts each valid project transactionally. `detach` is likewise a
 preview unless `--execute` is present. Attached projects use shared mode by
 default in `lean-runtime build`; detach before requesting `--local`.
+The attachment preview separates bytes removed from each checkout, compatible
+bytes already present in the shared store, new shared bytes that must be
+imported, and estimated machine-level recovery. These quantities differ on a
+first attachment because copy-on-write migration can shrink the repository
+without immediately freeing the dependency blocks retained by the shared copy.
 
 A new `init` target may be absent, empty, or an otherwise empty Git root, with
 an optional existing `AGENTS.md`. Git metadata and the custom guide are
 preserved. Planning rejects any other existing contents using the same
 validation as execution.
+Existing target directories are populated in place after staging verifies, so
+`lean-runtime init .` keeps the caller's current working directory valid.
 `--name NAME` overrides the inferred Lake package/root module name for a new
 project, which is useful when a lowercase repository name needs internal
 capitalization such as `IntegralFramework`.

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/docs/getting-started.md

@@ -21,12 +21,15 @@ shared exact dependencies:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check
 lean-runtime build
 ```
 
 By default, `init` writes an `AGENTS.md` explaining the project workflow and
 shared-dependency safety rules to coding agents. Pass `--no-agents` to omit it.
-An existing file is preserved.
+An existing file is preserved. The generated root imports only the project's
+local `Basic` module; add the narrow Mathlib imports each implementation file
+needs rather than paying for the all-Mathlib umbrella on every root import.
 
 Use `--mathlib 4.33.0` to select that release explicitly, or `--core` for a
 core-only library. The root project remains an ordinary mutable Lake project;
@@ -48,6 +51,8 @@ empty Git repository root. In the Git case, `init` preserves the existing HEAD,
 index, remotes, and worktree metadata. It also preserves an existing
 `AGENTS.md`; any other non-project contents are rejected by both `--plan` and
 execution rather than overwritten.
+If the target already exists, initialization keeps that directory inode alive;
+the shell that runs `lean-runtime init .` can immediately continue using it.
 The directory name normally supplies the Lake package/root module name. Override
 it when capitalization matters, for example:
 

lean_runtime-2.7.0/docs/lake-artifact-cache-design.md

@@ -0,0 +1,154 @@
+# Lake artifact-cache integration design
+
+!!! note
+
+    The root-only local cache and project-wide check described below are
+    implemented. Remote mappings remain deliberately gated on strong artifact
+    verification and acquisition planning.
+
+## Ownership
+
+Lean Runtime should complement the standard Lean tools rather than replace
+their build semantics:
+
+- Elan selects and installs the toolchain pinned by `lean-toolchain`.
+- Lake resolves packages and owns targets, facets, traces, executables, custom
+  build logic, and complete project builds.
+- Mathlib's cache supplies prebuilt upstream artifacts but does not cache a
+  downstream project's own outputs.
+- Lake's artifact cache shares input- and content-addressed outputs between
+  workspaces using the same toolchain and can register remote mappings for lazy
+  restoration.
+- Lean Runtime selects, verifies, distributes, and shares an exact environment
+  with provenance and download policy.
+
+Consequently, Lean Runtime must not implement a second general-purpose Lake
+target scheduler.
+
+## Public contract
+
+The intended commands are:
+
+```text
+lean-runtime check Foo.lean
+lean-runtime check
+lean-runtime build
+```
+
+`check Foo.lean` remains the focused development loop. A file-less `check`
+will check all local Lean modules without producing executables or native
+libraries. `build` remains a complete Lake-compatible build of declared local
+targets; it must not silently become a partial build.
+
+## Integration boundary
+
+`ProjectExecutor` owns project command selection and execution policy. A future
+`LakeArtifactCache` service should be injected into that executor and should
+own only cache location, mappings, and restoration:
+
+```text
+published OCI environment
+  ├── exact source and lock provenance
+  ├── sparse check capsule
+  └── Lake input-to-output mappings
+                 │
+                 ▼
+toolchain-scoped Lake artifact cache
+                 │
+                 ▼
+ProjectExecutor ─────► ordinary Lake target graph
+```
+
+The cache directory must be keyed by the exact Lean toolchain identity and
+platform ABI. It must never mix artifacts across incompatible toolchains.
+
+## Lake 4.33 experiment and decision
+
+The experiment used one generated Mathlib 4.33 project and preserved the same
+source and shared dependency graph for every measurement. The exact observed
+interface is checked into `compatibility/lake-artifact-cache-4.33.0.json`.
+
+Compare:
+
+1. the current bare Lake build through `lean-runtime build`;
+2. explicit root-package, local-library, root-module `leanArts`, and executable
+   targets;
+3. the same targets with `LAKE_ARTIFACT_CACHE=true` and a toolchain-scoped
+   `LAKE_CACHE_DIR`;
+4. the cache with publication mappings captured by `lake build -o` and
+   registered locally;
+5. warm process-cache and cold filesystem-cache runs.
+
+The broad workspace cache was rejected: it copied about 6.5 GB of dependency
+artifacts into a second cache and an explicit `@/Library:leanArts` target still
+traversed 8,708 jobs. A root package with `enableArtifactCache = true`, combined
+with workspace-level `LAKE_ARTIFACT_CACHE=false`, cached only root artifacts
+(about 396 KB in the fixture) and restored them in about five seconds. This is
+the implemented mode.
+
+Support is detected from command behavior and help surfaces, not a parsed Lake
+version. The verdict is cached by exact toolchain identity and platform ABI.
+Verbose Lake output provides deterministic hit markers such as `restored
+artifact from cache`; timing alone is not treated as proof of a hit.
+
+## Publication and acquisition
+
+When the remaining integrity and performance gates succeed, environment publication should run the ordinary
+verified build with a Lake mappings output. Publication should bind the mapping
+digest to the same exact source revision, complete Lake graph, toolchain, and
+platform record as the capsule.
+
+Acquisition should:
+
+1. verify the environment and mapping descriptors through the existing OCI
+   trust path;
+2. install compatible artifacts into the toolchain-scoped Lake cache or add
+   mappings that point to a configured remote service;
+3. leave Lake responsible for evaluating input traces and restoring outputs;
+4. fail explicitly on corrupt mappings or artifacts instead of silently
+   treating them as verified environment content;
+5. permit an ordinary source build when policy allows it.
+
+Lake recomputes its artifact hash after a remote fetch, but that hash is not a
+cryptographic integrity boundary. Lean Runtime therefore does not currently
+register remote mappings. A future remote adapter must bind a SHA-256 artifact
+inventory into the verified OCI record, verify every restored artifact, emit
+`acquisition.planned`, and charge all bytes against `max_download_bytes` before
+registration. Until then, remote object storage would be inside the trust
+boundary and is rejected.
+
+OCI remains the environment and provenance distribution format. Lake's cache
+format remains the build-cache contract. Translation between them belongs in a
+small adapter, not in capsule, registry, or project CLI code.
+
+## Performance gate
+
+The slice ships only if the same empty Mathlib project satisfies:
+
+| Journey | Budget |
+| --- | ---: |
+| Focused warm file check | at most 3 seconds |
+| Project-wide check | at most 10 seconds |
+| First build with shared cache ready | at most 10 seconds |
+| Warm no-op build | at most 3 seconds |
+| Executable build | comparable to native Lake |
+| Custom facet | handled unchanged by Lake |
+
+Correctness gates must include libraries, executables, multiple local modules,
+custom Lean options, Mathlib plus LeanCert, a supported custom facet, an
+unsupported cache entry, corrupted cache content, and concurrent projects using
+the same cache.
+
+The scheduled compatibility workflow runs the root-cache correctness and
+timing gate on macOS ARM and Linux x86. It verifies a first check, a warm check,
+and restoration after removing the checkout-local build directory. Ordinary CI
+also exercises toolchain/ABI key separation on both platforms. The cache does
+not participate in the focused `lake env lean` path; that path consumes already
+available imports directly.
+
+Explicit targets and the native cache did not remove dependency-graph
+traversal. The implemented fileless `check` therefore asks Lake to build only
+local library `leanArts` facets, preserving correct intra-project ordering. The
+next performance step is an opaque-prebuilt-dependency optimization in Lake.
+A specialized local-module scheduler remains a last resort and would be called
+`check`, never `build`.

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/docs/local-projects.md

@@ -46,12 +46,29 @@ each repository's `.lake/packages`. New projects can start in shared mode:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check
 lean-runtime build
 ```
 
+The fileless form asks Lake for the project's declared local libraries and
+builds their `leanArts` facets. Lake therefore expands roots and submodules,
+orders local imports, and creates any intermediate local `.olean` files; Lean
+Runtime does not parse module globs or implement a second build scheduler. It
+does not request executable or native-library targets. The Python equivalent is
+`Runtime().project(".").check_all()`.
+
+Projects created by `init` on a supported Lake also opt their root package into
+Lake's native artifact cache. Lean Runtime capability-probes the resolved Lake executable
+once, stores the result per exact toolchain and platform ABI, and otherwise
+stays silent. Only root-project outputs enter this cache: locked dependencies
+continue to use the verified shared workspace, avoiding a second multi-gigabyte
+copy. `build` retains Lake's complete target semantics.
+
 The generated files are a standard Lake project plus a small
 `lean-runtime.toml`. Root build outputs stay local; exact dependencies are
-shared. The newest stable cataloged Mathlib is selected by default. Select a
+shared. The generated root imports only its local `Basic` module, leaving
+implementation files free to select precise Mathlib modules. The newest stable
+cataloged Mathlib is selected by default. Select a
 release with `--mathlib 4.33.0`, or use `--core` for a core-only library.
 `init` also creates an `AGENTS.md` describing the safe
 build and dependency workflow unless `--no-agents` is passed; it never
@@ -69,10 +86,12 @@ toolchain is rejected under `--offline` or `--max-download` rather than silently
 bypassing the policy.
 
 An otherwise empty Git root is a valid new-project target. The original `.git`
-directory—or `.git` worktree file—is transferred through the atomic publication
-without changing HEAD, the index, or remotes. A pre-existing `AGENTS.md` is also
-preserved. Other contents must be moved first or represented by an existing
-pinned Lake project; the read-only plan enforces the same rule as execution.
+directory—or `.git` worktree file—stays in place without changing HEAD, the
+index, or remotes. The existing directory inode also stays live, so invoking
+`lean-runtime init .` does not strand the shell in an unlinked working
+directory. A pre-existing `AGENTS.md` is preserved. Other contents must be moved
+first or represented by an existing pinned Lake project; the read-only plan
+enforces the same rule as execution.
 Use `--name NAME` when creating inside a lowercase or otherwise differently
 named repository and the Lean root module needs an explicit spelling.
 
@@ -106,13 +125,15 @@ lean-runtime attach ~/research --recursive
 lean-runtime attach ~/research --recursive --execute
 ```
 
-The preview groups exact graphs, reports current and estimated shared storage,
-and identifies missing local paths, dirty dependencies, and revision
-mismatches. Execution continues through independent projects while reporting
-per-project failures. It first prepares the exact shared workspace and probes it
-through Lake. Only then does it atomically replace `.lake/packages` with package
-links, probe the resulting project through ordinary Lake, and discard the old
-generated copies. Any failure restores the original package directory.
+The preview groups exact graphs and separately reports checkout bytes removed,
+compatible shared bytes already ready, new shared bytes required, and estimated
+machine-level recovery. It also identifies missing local paths, dirty
+dependencies, and revision mismatches. Execution continues through independent
+projects while reporting per-project failures. It first prepares the exact
+shared workspace and probes it through Lake. Only then does it atomically
+replace `.lake/packages` with package links, probe the resulting project through
+ordinary Lake, and discard the old generated copies. Any failure restores the
+original package directory.
 
 The project itself remains portable. To return to independent package copies:
 
@@ -151,12 +172,20 @@ their artifacts.
 
 The first shared build imports a clean, revision-matching local dependency copy
 when one exists, using copy-on-write filesystem clones where supported. Missing
-sources are fetched at the exact manifest commit. A plain shared build never
+sources are fetched at the exact manifest commit. A later project bypasses
+source resolution when a managed package marker proves that its toolchain,
+platform, revision, and effective dependency closure already match. A plain shared build never
 deletes the old `.lake/packages`; only an explicit `attach --execute` replaces
 those generated copies after verification. `lean-runtime storage` reports
 shared project package usage; automatic cleanup of those packages is not yet
 implemented.
 
+Check capsules and mutable shared packages are intentionally separate storage
+tiers. Capsules are source-free and trimmed for checking; ordinary Lake
+development needs source-shaped packages and build metadata. A capsule can seed
+compatible build artifacts while the exact source workspace is materialized,
+but attached projects ultimately link to the mutable shared-project store.
+
 This mode requires a manifest and never runs `lake update`, so it cannot silently
 change dependency revisions. It also reuses an existing local Git object database
 when that database contains another requested revision, avoiding redundant Git

{lean_runtime-2.6.1 → lean_runtime-2.7.0}/lean_runtime/bundles.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import gzip
 import hashlib
 import io
-import json
 import os
 import re
 import shutil
@@ -38,6 +37,22 @@ from .events import EventEmitter
 from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock, LockedPackage
 from .locking import FileLock
+from .oci_protocol import (
+    INDEX_MEDIA_TYPE,
+    MANIFEST_MEDIA_TYPE,
+)
+from .oci_protocol import (
+    blob_descriptor_path as _blob_descriptor_path,
+)
+from .oci_protocol import (
+    descriptor_blob_path as _descriptor_blob_path,
+)
+from .oci_protocol import (
+    json_object as _json_object,
+)
+from .oci_protocol import (
+    require_media_type as _require_media_type,
+)
 from .packs import (
     PACK_MEDIA_TYPE,
     SparsePack,
@@ -60,8 +75,6 @@ CAPSULE_BUNDLE_SCHEMA = "lean-runtime-oci-capsule/1"
 CONFIG_MEDIA_TYPE = "application/vnd.lean-runtime.environment.config.v1+json"
 CAPSULE_CONFIG_MEDIA_TYPE = "application/vnd.lean-runtime.capsule.config.v1+json+zstd"
 LAYER_MEDIA_TYPE = "application/vnd.lean-runtime.environment.layer.v1.tar+gzip"
-MANIFEST_MEDIA_TYPE = "application/vnd.oci.image.manifest.v1+json"
-INDEX_MEDIA_TYPE = "application/vnd.oci.image.index.v1+json"
 MAX_BUNDLE_BYTES = 20 * 1024**3
 MAX_FILES = 2_000_000
 SOURCE_TREE_INVENTORY = ".lean-runtime-source-tree.json"
@@ -84,18 +97,6 @@ class PortableCopyInfo:
         }
 
 
-def _digest(data: bytes) -> str:
-    return "sha256:" + hashlib.sha256(data).hexdigest()
-
-
-def _digest_path(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return "sha256:" + digest.hexdigest()
-
-
 def _capsule_config_bytes(value: Mapping[str, Any]) -> bytes:
     return zstandard.ZstdCompressor(level=10, write_checksum=True).compress(
         canonical_json_bytes(dict(value))
@@ -112,19 +113,6 @@ def _capsule_config_object(data: bytes) -> dict[str, Any]:
     return _json_object(decoded, "capsule config")
 
 
-def _blob_descriptor(data: bytes, media_type: str, **extra: Any) -> dict[str, Any]:
-    return {"mediaType": media_type, "digest": _digest(data), "size": len(data), **extra}
-
-
-def _blob_descriptor_path(path: Path, media_type: str, **extra: Any) -> dict[str, Any]:
-    return {
-        "mediaType": media_type,
-        "digest": _digest_path(path),
-        "size": path.stat().st_size,
-        **extra,
-    }
-
-
 def _normalized_info(name: str, *, mode: int, kind: bytes = tarfile.REGTYPE) -> tarfile.TarInfo:
     info = tarfile.TarInfo(name)
     info.type = kind
@@ -245,43 +233,6 @@ def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
                 archive.addfile(info, handle)
 
 
-def _json_object(data: bytes, label: str) -> dict[str, Any]:
-    try:
-        value = json.loads(data)
-    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
-        raise EnvironmentError(f"bundle {label} is not valid JSON") from exc
-    if not isinstance(value, dict):
-        raise EnvironmentError(f"bundle {label} must be a JSON object")
-    return value
-
-
-def _descriptor_blob(entries: dict[str, bytes], descriptor: dict[str, Any], label: str) -> bytes:
-    digest = descriptor.get("digest")
-    size = descriptor.get("size")
-    if not isinstance(digest, str) or not digest.startswith("sha256:"):
-        raise EnvironmentError(f"bundle {label} has an invalid digest")
-    data = entries.get("blobs/sha256/" + digest.removeprefix("sha256:"))
-    if data is None or len(data) != size or _digest(data) != digest:
-        raise EnvironmentError(f"bundle {label} digest mismatch")
-    return data
-
-
-def _descriptor_blob_path(entries: dict[str, Path], descriptor: dict[str, Any], label: str) -> Path:
-    digest = descriptor.get("digest")
-    size = descriptor.get("size")
-    if not isinstance(digest, str) or not digest.startswith("sha256:"):
-        raise EnvironmentError(f"bundle {label} has an invalid digest")
-    path = entries.get("blobs/sha256/" + digest.removeprefix("sha256:"))
-    if path is None or path.stat().st_size != size or _digest_path(path) != digest:
-        raise EnvironmentError(f"bundle {label} digest mismatch")
-    return path
-
-
-def _require_media_type(descriptor: dict[str, Any], expected: str, label: str) -> None:
-    if descriptor.get("mediaType") != expected:
-        raise EnvironmentError(f"bundle {label} has an unsupported media type")
-
-
 def _safe_name(name: str) -> PurePosixPath:
     path = PurePosixPath(name)
     if (