lean-runtime 2.6.2__tar.gz → 2.8.0__tar.gz

{lean_runtime-2.6.2 → lean_runtime-2.8.0}/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## Unreleased
 
+## 2.8.0 - 2026-08-14
+
+- Cut repeated project-check latency with capability-probed Lean header snapshots;
+  `check --watch` rechecks on save, while `check --repeat` and `check --across`
+  absorb the common profile/matrix workflows without removing legacy aliases.
+- Suggest exact-workspace declarations after coded unknown-identifier diagnostics
+  using persisted `.ilean` indexes from the pinned dependency graph.
+- Make `init --mathlib-version VERSION` unambiguous, preserve common repository
+  scaffolding, optionally generate matching CI with `--ci`, and retain the old
+  `--mathlib` spelling as a validated compatibility alias.
+- Add `project scan/attach/detach/update`, `publish KIND`, `finalize KIND`, and
+  `copy save/open` namespaces while retaining existing command spellings for
+  automation.
+- Give environments and doctor human output plus `--json`, add `doctor --fix`,
+  fingerprinted storage accounting with `storage --verify`, cleanup nudges,
+  `clean --keep-last` retention, curated help, and generated Bash/Zsh/Fish
+  completions.
+- Report cumulative frame and byte counters while restoring sparse capsules, so
+  both terse and verbose cold-start output shows measurable forward progress.
+
+## 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-2.6.2/lean_runtime.egg-info → lean_runtime-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.6.2
+Version: 2.8.0
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -188,13 +188,16 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check MyProof/Basic.lean --watch
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 
 `init` also writes an `AGENTS.md` with the project build, checking, dependency,
 and shared-package rules for coding agents. Pass `--no-agents` to omit it; an
 existing `AGENTS.md` is never overwritten. Use `--core` for no Mathlib, or
-`--mathlib 4.33.0` to select a cataloged release. `lean-runtime update`
+`--mathlib-version 4.33.0` to select a cataloged release. `lean-runtime update`
 explicitly moves a project to the newest cataloged Mathlib after a preview.
 
 Running `lean-runtime init .` in an existing pinned Lake project adopts its

{lean_runtime-2.6.2 → lean_runtime-2.8.0}/README.md

@@ -152,13 +152,16 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check MyProof/Basic.lean --watch
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 
 `init` also writes an `AGENTS.md` with the project build, checking, dependency,
 and shared-package rules for coding agents. Pass `--no-agents` to omit it; an
 existing `AGENTS.md` is never overwritten. Use `--core` for no Mathlib, or
-`--mathlib 4.33.0` to select a cataloged release. `lean-runtime update`
+`--mathlib-version 4.33.0` to select a cataloged release. `lean-runtime update`
 explicitly moves a project to the newest cataloged Mathlib after a preview.
 
 Running `lean-runtime init .` in an existing pinned Lake project adopts its

lean_runtime-2.8.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.8.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.8.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.8.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.2 → lean_runtime-2.8.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.2 → lean_runtime-2.8.0}/docs/cli.md

@@ -32,6 +32,19 @@ first-time download cannot expire the search. `--discovery-timeout` and
 
 All commands accept `--home PATH` before the subcommand to select a store.
 
+For project iteration, `check FILE --watch` rechecks on save with warm native
+import snapshots. `check FILE --repeat N` measures the same path, and
+`check FILE --across matrix.toml` checks exact contexts. The older `profile`
+and `matrix` commands remain compatibility aliases.
+
+`storage` reads a fingerprinted ledger after its first inventory, so large
+stores remain an instant-information command. `storage --verify` explicitly
+rebuilds that ledger and prints a progress line because it must walk the store.
+`doctor` is human-readable by default; `doctor --json` preserves automation and
+`doctor --fix` applies its safe stale-staging and private-Elan remedies.
+`clean --keep-last N` (or `LEAN_RUNTIME_CLEAN_KEEP_LAST`) retains the newest N
+otherwise eligible unnamed environments in addition to the age threshold.
+
 ## One-shot package workflow
 
 ```bash
@@ -61,9 +74,9 @@ lean-runtime check Main.lean \
 lean-runtime prepare environment.toml --output environment.lock.json
 lean-runtime open environment.lock.json --name research-stack
 lean-runtime --library ghcr.io/owner/lean-environments download environment.lock.json
-lean-runtime save-copy research-stack --output research-stack.lean-environment
-lean-runtime --home /tmp/fresh open-copy research-stack.lean-environment --name research-stack
-lean-runtime build-and-publish environment.lock.json --publish-to ghcr.io/owner/lean-environments
+lean-runtime copy save research-stack --output research-stack.lean-environment
+lean-runtime --home /tmp/fresh copy open research-stack.lean-environment --name research-stack
+lean-runtime publish environment environment.lock.json --publish-to ghcr.io/owner/lean-environments
 lean-runtime check research-stack Main.lean --json
 lean-runtime inspect research-stack --packages
 lean-runtime environments
@@ -79,9 +92,10 @@ lean-runtime clean --execute
 
 `clean` is a dry run unless `--execute` is supplied.
 
-`save-copy` creates a portable environment file. `open-copy` verifies its exact
+`copy save` creates a portable environment file. `copy open` verifies its exact
 identity, package Git trees, computer compatibility, and Lean probe before
-making the environment available. See [Portable copies and environment
+making the environment available. The former `save-copy` and `open-copy`
+spellings remain compatibility aliases. See [Portable copies and environment
 libraries](portable-copies.md) for its trust boundary.
 
 ## Slim toolchains

{lean_runtime-2.6.2 → lean_runtime-2.8.0}/docs/getting-started.md

@@ -21,14 +21,19 @@ shared exact dependencies:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check MyProof/Basic.lean --watch
+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. Pass `--ci` to generate a workflow that checks
+the same exact committed project graph. 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
+Use `--mathlib-version 4.33.0` to select that release explicitly, or `--core` for a
 core-only library. The root project remains an ordinary mutable Lake project;
 its dependency sources and build artifacts are reused by other projects with
 the same exact graph.
@@ -78,6 +83,8 @@ lean-runtime scan ~/research
 ```
 
 `scan` only records exact local graphs as possible future zero-download seeds.
+The converged spelling is `lean-runtime project scan`; `project attach`,
+`project detach`, and `project update` group the other dependency-graph actions.
 Advanced bulk migration remains available through `attach`. See [Local Lake
 projects](local-projects.md) for detachment, storage estimates, and the complete
 safety model.

lean_runtime-2.8.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.2 → lean_runtime-2.8.0}/docs/local-projects.md

@@ -46,13 +46,38 @@ 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 MyProof/Basic.lean --watch
+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.
+
+Repeated file checks reuse Lean's native header snapshots, keyed by the exact
+toolchain, project identity, and import block. Body-only edits therefore avoid
+reloading the unchanged import environment. `--watch` is a thin save loop over
+the same ordinary check/result contract. Failed checks may add exact-graph
+identifier hints derived from pinned `.ilean` indexes; raw Lean streams remain
+unchanged.
+
 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
-release with `--mathlib 4.33.0`, or use `--core` for a core-only library.
+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-version 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
 overwrites an existing guide.

{lean_runtime-2.6.2 → lean_runtime-2.8.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 (