@@ -43,6 +43,14 @@ lossy conversion is performed. Decoded-byte estimates assume full inner-chunk de
 partial codecs can do better. Transport bytes must be measured by the backend, not inferred
 from those estimates. A large logical shape is not evidence of large physical I/O throughput.
 
+Zarrista strided reads gather only touched inner chunks. When partial shard decoding is
+available, the adapter reuses one shard index while gathering those chunks and discards
+it before moving to another shard or returning from the read. Index bytes and native
+bookkeeping are additional to the read-buffer allowance; no field payload is cached by
+this mechanism. Reads after a completed external write create fresh indexes. Concurrent
+source mutation still requires snapshot isolation supplied by the caller. An outer
+shard codec uses whole-shard accounting and the ordinary subset reader.
+
 `arrayroute.statistics.ChannelMoments` accumulates or merges channel-last population
 statistics from bounded buffers, with optional per-channel validity masks. It keeps integer
 counts and centred float64 moments; missing observations do not contaminate the result.
 
@@ -1,6 +1,6 @@
 [project]
 name = "arrayroute"
-version = "0.1.4"
+version = "0.1.5"
 description = "Measured, bounded selections over scientific chunked arrays"
 requires-python = ">=3.11"
 license = "Apache-2.0"
 
@@ -40,7 +40,9 @@ def __init__(self, array: Any):
         self.dtype = np.dtype(array.metadata["data_type"])
         chunks = array.effective_subchunk_shape or array.chunk_shape([0] * array.ndim)
         codecs = array.metadata["codecs"]
-        if any(c["name"] == "sharding_indexed" for c in codecs[:-1]):
+        outer_codec = any(c["name"] == "sharding_indexed" for c in codecs[:-1])
+        self._partial_shards = array.is_sharded and not outer_codec
+        if outer_codec:
             # A codec outside the shard requires decoding the complete shard.
             chunks = array.chunk_shape([0] * array.ndim)
         self.spec = ArraySpec(tuple(array.shape), tuple(chunks), self.dtype.itemsize)
@@ -59,10 +61,32 @@ def _contiguous(self, selection: Selection) -> np.ndarray:
     def _strided(self, selection: Selection) -> np.ndarray:
         request = plan(self.spec, selection)
         result = np.empty(request.output_shape, dtype=self.dtype)
+        cache = self.array.shard_cache() if self._partial_shards else None
+        shard_shape = self.array.chunk_shape([0] * self.array.ndim) if cache is not None else ()
+        active_shard = None
 
         def visit(axis, sources, targets, strides):
+            nonlocal active_shard
             if axis == len(selection):
-                result[tuple(targets)] = self._contiguous(tuple(sources))[tuple(strides)]
+                if cache is None:
+                    value = self._contiguous(tuple(sources))
+                else:
+                    starts = [s if isinstance(s, int) else s.start for s in sources]
+                    shard = tuple(p // c for p, c in zip(starts, shard_shape, strict=True))
+                    if shard != active_shard:
+                        # Retain at most one index, and never reuse it across read calls.
+                        cache.clear()
+                        active_shard = shard
+                    chunks = self.spec.chunks
+                    coordinates = [p // c for p, c in zip(starts, chunks, strict=True)]
+                    local = tuple(
+                        s % c if isinstance(s, int)
+                        else slice(s.start % c, s.start % c + s.stop - s.start)
+                        for s, c in zip(sources, chunks, strict=True)
+                    )
+                    value = np.asarray(self.array.retrieve_subchunk(
+                        coordinates, shard_cache=cache))[local]
+                result[tuple(targets)] = value[tuple(strides)]
                 return
             sel, chunk = request.selection[axis], self.spec.chunks[axis]
             if isinstance(sel, int):
 
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+import numpy as np
+import pytest
+import zarr
+
+from arrayroute import ArrayReader
+from arrayroute.backends import ZarristaBackend
+
+zarrista = pytest.importorskip('zarrista')
+
+
+@pytest.mark.parametrize('sharded', [False, True])
+def test_strides_match_bits_across_partial_shards_and_missing_chunks(tmp_path, sharded):
+    rng = np.random.default_rng(289)
+    values = rng.integers(0, 2**32, size=(9, 13, 7), dtype=np.uint32).view(np.float32)
+    path = tmp_path / 'field.zarr'
+    options = {'shards': (6, 8, 4)} if sharded else {}
+    stored = zarr.create_array(path, shape=values.shape, dtype='f4', chunks=(3, 4, 2),
+                               fill_value=-7, **options)
+    stored[:6] = values[:6]
+    values[6:] = -7
+    backend = ZarristaBackend(zarrista.Array.open(zarrista.store.FilesystemStore(str(path))))
+    for budget in [400, 1 << 20]:
+        reader = ArrayReader(backend, buffer_bytes=budget)
+        for selection in [
+            (slice(1, 9, 2), slice(2, 13, 3), 3),
+            (7, slice(None, None, 2), slice(1, 7, 3)),
+            (slice(None, None, 4), 0, slice(None, None, 2)),
+            (slice(0, 0, 2), slice(None), slice(None)),
+        ]:
+            assert reader.read(selection).tobytes() == values[selection].tobytes()
+
+
+def test_shard_index_does_not_outlive_read_or_accumulate(tmp_path):
+    path = tmp_path / 'field.zarr'
+    values = np.arange(16 * 24, dtype='f4').reshape(16, 24)
+    stored = zarr.create_array(path, data=values, chunks=(2, 3), shards=(4, 6))
+    native = zarrista.Array.open(zarrista.store.FilesystemStore(str(path)))
+    caches, sizes = [], []
+
+    class Observed:
+        def __getattr__(self, name):
+            return getattr(native, name)
+
+        def shard_cache(self):
+            cache = native.shard_cache()
+            caches.append(cache)
+            return cache
+
+        def retrieve_subchunk(self, coordinates, *, shard_cache):
+            value = native.retrieve_subchunk(coordinates, shard_cache=shard_cache)
+            sizes.append(shard_cache.size())
+            return value
+
+    reader = ArrayReader(ZarristaBackend(Observed()), buffer_bytes=1 << 20)
+    selection = (slice(1, 16, 2), slice(0, 24, 2))
+    assert reader.read(selection).tobytes() == values[selection].tobytes()
+    stored[:] = values + 7
+    assert reader.read(selection).tobytes() == (values + 7)[selection].tobytes()
+    assert len(caches) == 2 and caches[0] is not caches[1]
+    assert sizes and max(sizes) == 1
+
+
+def test_outer_shard_codec_strides_use_whole_shard_budget(tmp_path):
+    from zarr.codecs import BytesCodec, ShardingCodec, ZstdCodec
+
+    path = tmp_path / 'field.zarr'
+    values = np.arange(32 * 32, dtype='f4').reshape(32, 32)
+    with pytest.warns(UserWarning, match='disables partial'):
+        stored = zarr.create_array(path, shape=values.shape, chunks=(16, 16), dtype='f4',
+            serializer=ShardingCodec(chunk_shape=(8, 8), codecs=[BytesCodec()]),
+            compressors=[ZstdCodec()])
+    stored[:] = values
+    backend = ZarristaBackend(zarrista.Array.open(zarrista.store.FilesystemStore(str(path))))
+    selection = (slice(1, 32, 3), slice(2, 32, 4))
+    reader = ArrayReader(backend, buffer_bytes=2048)
+    assert reader.read(selection).tobytes() == values[selection].tobytes()