refactor: rename ResolvedChunking to ChunkLayout

Names the structure (a layout) rather than the operation that produced it.
Reads cleanly for both sharded and unsharded cases, fits the recursive
inner-layout pattern, and is what one reaches for when reading the code cold.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: d-v-b

src/zarr/core/chunk_grids.py

@@ -52,7 +52,7 @@
 """
 
 
-class ResolvedChunking(NamedTuple):
+class ChunkLayout(NamedTuple):
     """Result of resolving user `chunks`/`shards` into grid metadata inputs.
 
     outer_chunks
@@ -66,7 +66,7 @@ class ResolvedChunking(NamedTuple):
     """
 
     outer_chunks: ChunksTuple
-    inner: ResolvedChunking | None = None
+    inner: ChunkLayout | None = None
 
 
 @dataclass(frozen=True)
@@ -822,7 +822,7 @@ def resolve_outer_and_inner_chunks(
     chunks: ChunksTuple,
     shard_shape: ShardsLike | None,
     item_size: int,
-) -> ResolvedChunking:
+) -> ChunkLayout:
     """Resolve user `chunks`/`shards` into outer and inner chunk specs.
 
     Parameters
@@ -841,18 +841,18 @@ def resolve_outer_and_inner_chunks(
 
     Returns
     -------
-    ResolvedChunking
+    ChunkLayout
         `outer_chunks` is the `ChunksTuple` for chunk grid
         metadata.  `inner` holds the sub-chunk structure for
         `ShardingCodec`, or is `None` when sharding is not active.
     """
     if shard_shape is None:
-        return ResolvedChunking(outer_chunks=chunks)
+        return ChunkLayout(outer_chunks=chunks)
 
     # Rectilinear shards: normalize the nested sequence directly.
     if _is_rectilinear_chunks(shard_shape):
         outer = normalize_chunks_nd(shard_shape, array_shape)
-        return ResolvedChunking(outer_chunks=outer, inner=ResolvedChunking(outer_chunks=chunks))
+        return ChunkLayout(outer_chunks=outer, inner=ChunkLayout(outer_chunks=chunks))
 
     # Extract the flat chunk shape (first size per dimension) for arithmetic.
     chunk_shape_flat = tuple(int(dim[0]) for dim in chunks)
@@ -888,4 +888,4 @@ def resolve_outer_and_inner_chunks(
         shard_flat = cast("tuple[int, ...]", shard_shape)
 
     outer = normalize_chunks_nd(shard_flat, array_shape)
-    return ResolvedChunking(outer_chunks=outer, inner=ResolvedChunking(outer_chunks=chunks))
+    return ChunkLayout(outer_chunks=outer, inner=ChunkLayout(outer_chunks=chunks))

tests/test_chunk_grids.py

@@ -106,16 +106,16 @@ def test_resolve_outer_and_inner_chunks(
         assert inner.inner is None
 
 
-def test_resolved_chunking_nested() -> None:
-    """Test that ResolvedChunking supports recursive nesting for nested sharding."""
-    from zarr.core.chunk_grids import ResolvedChunking
+def test_chunk_layout_nested() -> None:
+    """Test that ChunkLayout supports recursive nesting for nested sharding."""
+    from zarr.core.chunk_grids import ChunkLayout
 
     leaf = normalize_chunks_nd((5, 5), (100, 100))
-    mid = ResolvedChunking(
+    mid = ChunkLayout(
         outer_chunks=normalize_chunks_nd((25, 25), (100, 100)),
-        inner=ResolvedChunking(outer_chunks=leaf),
+        inner=ChunkLayout(outer_chunks=leaf),
     )
-    top = ResolvedChunking(outer_chunks=normalize_chunks_nd((50, 50), (100, 100)), inner=mid)
+    top = ChunkLayout(outer_chunks=normalize_chunks_nd((50, 50), (100, 100)), inner=mid)
 
     # Three levels: top -> mid -> leaf
     _assert_chunks_equal(top.outer_chunks, ((50, 50), (50, 50)))