@@ -46,6 +46,10 @@ fallbacks.
 ## Index and object metadata lifecycle
 
 `IndexFile` queries immutable entry records; it does not retain a parsed index.
+The compatibility `entries` property projects those queries into a read-only
+snapshot keyed by path and stage, preserving readers in dlt and Renku. It uses
+the same Gix-backed default-index query or documented Git fallback as
+`iter_entries()`; snapshots do not become editable index state.
 Deferred/virtual state consists of opaque file bytes, materialized before Git
 operates and read back only after success. Private edits use Git because native
 bindings cannot load an arbitrary existing index (GIX-3) or validate a checked
 
@@ -101,8 +101,11 @@ API changes
   Fetch/pull results are derived from command output rather than ``FETCH_HEAD``
   file parsing. Revision strings follow Git's native revision grammar.
 
-* ``IndexFile.entries`` is removed. Use ``iter_entries()`` for immutable query
-  records, ``entry(path, stage=0)`` for exact lookup (missing entries raise
+* ``IndexFile.entries`` returns an immutable snapshot keyed by ``(path, stage)``
+  for compatibility with existing readers. Each access queries the current
+  on-disk or pending index; previously returned snapshots retain their values.
+  Direct mutation of the mapping is removed. Use ``iter_entries()`` for immutable
+  query records, ``entry(path, stage=0)`` for exact lookup (missing entries raise
   ``KeyError``), ``add()``, and ``remove()`` for edits. Python retains only opaque
   index-file bytes for deferred/virtual indexes. Git edits private files and
   validates readback before atomic publication. ``add(write=False)`` and
 
@@ -341,7 +341,7 @@ As trees allow direct access to their intermediate child entries only, use the t
 
 The Index Object
 ****************
-The git index is the stage containing changes to be written with the next commit or where merges finally have to take place. Use :meth:`IndexFile.iter_entries <git.index.base.IndexFile.iter_entries>` and :meth:`IndexFile.entry <git.index.base.IndexFile.entry>` to query immutable entry records (mode, object ID, path, and stage); use ``add`` and ``remove`` to edit them. Deferred edits retain opaque index-file bytes. Git reads and writes the underlying index; raw stat fields and binary index extensions are not exposed.
+The git index is the stage containing changes to be written with the next commit or where merges finally have to take place. Use :meth:`IndexFile.iter_entries <git.index.base.IndexFile.iter_entries>` and :meth:`IndexFile.entry <git.index.base.IndexFile.entry>` to query immutable entry records (mode, object ID, path, and stage). The ``entries`` property provides a read-only snapshot keyed by ``(path, stage)`` for existing readers; use ``add`` and ``remove`` to edit the index. Deferred edits retain opaque index-file bytes. Git reads and writes the underlying index; raw stat fields and binary index extensions are not exposed.
 Modify the index with ease
 
 .. literalinclude:: ../../test/test_docs.py
 
@@ -18,6 +18,7 @@
 import subprocess
 import shutil
 import tempfile
+from types import MappingProxyType
 
 from gitdb.base import IStream
 
@@ -60,6 +61,7 @@
     Iterable,
     Iterator,
     List,
+    Mapping,
     NoReturn,
     Sequence,
     TYPE_CHECKING,
@@ -148,6 +150,15 @@ def iter_entries(self) -> Iterator[IndexEntry]:
             with self._materialized_index() as path:
                 yield from self._read_entries(path)
 
+    @property
+    def entries(self) -> Mapping[Tuple[PathLike, StageType], IndexEntry]:
+        """Return an immutable snapshot keyed by path and merge stage.
+
+        Each access queries the current on-disk or pending index. Use :meth:`add`
+        and :meth:`remove` to edit the index; the snapshot is never written back.
+        """
+        return MappingProxyType({entry_key(entry): entry for entry in self.iter_entries()})
+
     def entry(self, path: PathLike, stage: StageType = 0) -> IndexEntry:
         """Return the exact path/stage entry; raise ``KeyError`` if absent."""
         for entry in self.iter_entries():
 
@@ -180,7 +180,7 @@ def test_pending_index_queries_removal_and_failed_update(repo):
     index.add(["file"], write=False)
     pending = index.entry("file")
     assert pending.binsha != original.binsha
-    assert not hasattr(index, "entries")
+    assert index.entries[("file", 0)] == pending
     with pytest.raises(ValueError, match="Git did not retain"):
         index.add([BaseIndexEntry((0o120000, pending.binsha, 0, ".gitmodules"))], write=False)
     with pytest.raises(ValueError, match="Invalid index path"):
 
@@ -0,0 +1,33 @@
+"""Public GitPython queries used by released downstream projects."""
+
+from pathlib import Path
+
+import pytest
+
+from test.lib.fixtures import fixture_repo
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_index_entries_readers_retain_pending_and_published_snapshots(object_format, ref_format):
+    with fixture_repo("downstream-index.sh", object_format, ref_format, write=True) as repo:
+        index = repo.index
+        published_bytes = Path(index.path).read_bytes()
+        entries = index.entries
+        assert len(entries) == 4
+        assert set(entries.keys()) == {("tracked", 0), *(("conflict", stage) for stage in (1, 2, 3))}
+        assert [str(key[0]) for key in entries].count("conflict") == 3
+        assert entries[("tracked", 0)].binsha == repo.head.commit.tree["tracked"].binsha
+        assert all(entry.path == path and entry.stage == stage for (path, stage), entry in entries.items())
+        with pytest.raises(KeyError):
+            entries[("missing", 0)]
+        with pytest.raises(TypeError):
+            entries[("tracked", 0)] = entries[("conflict", 1)]
+        index.add(["tracked"], write=False)
+        pending = index.entries
+        assert pending[("tracked", 0)].binsha != entries[("tracked", 0)].binsha
+        assert repo.index.entries[("tracked", 0)] == entries[("tracked", 0)]
+        assert Path(index.path).read_bytes() == published_bytes
+        index.write()
+        assert repo.index.entries == pending
+        assert entries[("tracked", 0)].binsha == repo.head.commit.tree["tracked"].binsha
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -eu
+git init -q --object-format="$1" --ref-format="$2" repo
+cd repo
+printf initial > tracked
+git add tracked
+git commit -qm initial
+oid=$(git rev-parse HEAD:tracked)
+for stage in 1 2 3; do
+    printf '100644 %s %s\tconflict\n' "$oid" "$stage"
+done | git update-index --index-info
+printf changed > tracked