@@ -1 +1 @@
-Chunk specifications are judged only by the chunk normalizer: the separate duck-typed check for rectilinear input is gone, so the Zarr format 2 and sharding restrictions apply to what the normalized grid says was declared. A chunk size is an integer by Python's integer protocol: numpy integer scalars and 0-d integer arrays are accepted wherever a chunk or shard shape is. The legacy `zarr.create(..., zarr_format=2)` no longer tests the truth value of `chunks`: only `None` means not given, as for Zarr format 3. `chunks=False` is now one chunk instead of an automatic chunk shape, numpy arrays work, and `0`, `[]` and `np.array([0])` raise instead of chunking automatically. A non-integer scalar chunk specification raises a `TypeError` naming the problem. An explicit list of chunk edges declares a rectilinear dimension everywhere, including a stored rectilinear chunk grid passed as `chunks=` whose edges happen to be uniform, so the Zarr format 2 and sharding restrictions treat it the same whether it is given as lists or as metadata, and `zarr.create` stores it as a rectilinear chunk grid, as `create_array` does. A `RectilinearChunkGridMetadata` made only of bare integers declares no explicit edge list, so it is read as the regular grid it describes: it is accepted for Zarr format 2 and as the chunk shape of a sharded array. The `chunks` and `chunk_shape` parameters of `zarr.create` and the `ShardsLike` type now declare every chunk specification the normalizer accepts, including numpy integers and arrays, explicit edge lists and stored chunk grid metadata.
+Chunk specifications are judged only by the chunk normalizer: the separate duck-typed check for rectilinear input is gone, so the Zarr format 2 and sharding restrictions apply to what the normalized grid says was declared. A chunk size is an integer by Python's integer protocol: numpy integer scalars and 0-d integer arrays are accepted wherever a chunk or shard shape is. The legacy `zarr.create(..., zarr_format=2)` no longer tests the truth value of `chunks`: only `None` means not given, as for Zarr format 3. `chunks=False` is now one chunk instead of an automatic chunk shape, numpy arrays work, and `0`, `[]` and `np.array([0])` raise instead of chunking automatically. A non-integer scalar chunk specification raises a `TypeError` naming the problem. An explicit list of chunk edges declares a rectilinear dimension everywhere, including a stored rectilinear chunk grid passed as `chunks=` whose edges happen to be uniform, so the Zarr format 2 and sharding restrictions treat it the same whether it is given as lists or as metadata, and `zarr.create` stores it as a rectilinear chunk grid, as `create_array` does. A `RectilinearChunkGridMetadata` made only of bare integers declares no explicit edge list, so it is read as the regular grid it describes: it is accepted for Zarr format 2 and as the chunk shape of a sharded array. The `chunks` and `chunk_shape` parameters of `zarr.create` and the `ShardsLike` type now declare every chunk specification the normalizer accepts, including numpy integers and arrays, explicit edge lists and stored chunk grid metadata. The inner chunk shape of `ShardingCodec` is parsed with the chunk normalizer's integer test as a regular chunk shape: every size must be at least 1, so a stored or given inner chunk size of 0 raises a `ValueError` instead of a `ZeroDivisionError` on read, and an explicit list of chunk edges is rejected with a `TypeError`.
@@ -36,7 +36,7 @@
     default_buffer_prototype,
     numpy_buffer_prototype,
 )
-from zarr.core.chunk_grids import ChunkGrid
+from zarr.core.chunk_grids import ChunkGrid, parse_regular_chunk_shape
 from zarr.core.chunk_utils import (
     ChunkTransform,
     decode_and_scatter_chunk,
@@ -47,7 +47,6 @@
 from zarr.core.common import (
     ShapeLike,
     parse_named_configuration,
-    parse_shapelike,
     product,
 )
 from zarr.core.config import config as zarr_config
@@ -468,7 +467,7 @@ def __init__(
         index_location: ShardingCodecIndexLocation | IndexLocation = "end",
         subchunk_write_order: SubchunkWriteOrder = "morton",
     ) -> None:
-        chunk_shape_parsed = parse_shapelike(chunk_shape)
+        chunk_shape_parsed = parse_regular_chunk_shape(chunk_shape)
         codecs_parsed = parse_codecs(codecs)
         index_codecs_parsed = parse_codecs(index_codecs)
         _check_index_codecs_fixed_size(index_codecs_parsed)
@@ -507,7 +506,7 @@ def __getstate__(self) -> dict[str, Any]:
 
     def __setstate__(self, state: dict[str, Any]) -> None:
         config = state["configuration"]
-        object.__setattr__(self, "chunk_shape", parse_shapelike(config["chunk_shape"]))
+        object.__setattr__(self, "chunk_shape", parse_regular_chunk_shape(config["chunk_shape"]))
         object.__setattr__(self, "codecs", parse_codecs(config["codecs"]))
         object.__setattr__(self, "index_codecs", parse_codecs(config["index_codecs"]))
         object.__setattr__(self, "index_location", _parse_index_location(config["index_location"]))
 
@@ -851,6 +851,35 @@ def normalize_chunks_nd(
     )
 
 
+def parse_regular_chunk_shape(chunk_shape: ShapeLike) -> tuple[int, ...]:
+    """Parse the chunk shape of a regular chunk grid that has no array shape to be
+    normalized against, such as the inner chunk shape of a shard.
+
+    The chunk normalizer's integer test (`_chunk_int`) decides what a chunk size is, and
+    every chunk size is at least 1. A single integer is a one-dimensional chunk shape.
+    Without the lengths of the axes `-1` and `False` cannot be resolved, so they are
+    rejected as non-positive; an explicit list of chunk edges declares a rectilinear
+    dimension, which a regular chunk grid cannot have, and is rejected as a non-integer.
+    """
+    size = _chunk_int(chunk_shape)
+    elements = [size] if size is not None else _chunk_list(chunk_shape)
+    as_ints = [_chunk_int(e) for e in elements]
+    non_int = [
+        (idx, e) for idx, (e, i) in enumerate(zip(elements, as_ints, strict=True)) if i is None
+    ]
+    if non_int:
+        non_int_idxs, non_int_vals = [*zip(*non_int, strict=False)]
+        raise TypeError(
+            f"Each chunk size of a regular chunk shape must be an integer; got non-integer "
+            f"element(s) {non_int_vals!r} at indices {non_int_idxs!r}. A regular chunk shape "
+            f"is a flat sequence of positive integers, one per dimension (e.g. [10, 10])."
+        )
+    sizes = tuple(i for i in as_ints if i is not None)
+    if any(c < 1 for c in sizes):
+        raise ValueError(f"All chunk sizes must be positive, got {list(sizes)}")
+    return sizes
+
+
 def guess_chunks(
     shape: tuple[int, ...], typesize: int, *, max_bytes: int | None = None
 ) -> ChunkGrid:
 
@@ -2,7 +2,7 @@
 import math
 import pickle
 import warnings
-from typing import Any, cast, get_args
+from typing import TYPE_CHECKING, Any, cast, get_args
 from unittest.mock import AsyncMock
 
 import numpy as np
@@ -40,6 +40,9 @@
 from ..conftest import ArrayRequest
 from .test_codecs import _AsyncArrayProxy, order_from_dim
 
+if TYPE_CHECKING:
+    from zarr.core.common import JSON
+
 
 def _reads_are_sync(store_mock: AsyncMock) -> bool:
     """True when the partial-shard read for this store+pipeline goes through the
@@ -765,15 +768,13 @@ def test_structured_dtype_fill_value() -> None:
     [
         ShardingCodec(chunk_shape=(8, 8)),
         ShardingCodec(chunk_shape=(8, 8), subchunk_write_order="lexicographic"),
-        ShardingCodec(chunk_shape=(0,)),
     ],
-    ids=["default", "lexicographic", "zero-chunk-size"],
+    ids=["default", "lexicographic"],
 )
 def test_pickle(codec: ShardingCodec) -> None:
     """ShardingCodec round-trips through pickle, including the non-serialized
     ``subchunk_write_order`` (which ``to_dict`` omits and which must not silently
-    revert to the ``morton`` default), and an inner chunk size of 0, which the
-    constructor accepts."""
+    revert to the ``morton`` default)."""
     restored = pickle.loads(pickle.dumps(codec))
     assert restored == codec
     assert restored.chunk_shape == codec.chunk_shape
@@ -1395,3 +1396,51 @@ def test_sharding_orthogonal_set_multiple_array_dims(
         expected[ix] = value.reshape(expected[ix].shape)
         assert np.array_equal(a[:], expected)
         assert np.array_equal(a.oindex[selection], value)
+
+
+@pytest.mark.parametrize(
+    ("chunk_shape", "expected"),
+    [
+        ((4,), (4,)),
+        ([4, 2], (4, 2)),
+        (4, (4,)),
+        (np.int64(4), (4,)),
+        ((np.int64(4),), (4,)),
+        (np.array([4]), (4,)),
+        ((True,), (1,)),
+        (range(4, 5), (4,)),
+        ((), ()),
+    ],
+    ids=repr,
+)
+def test_sharding_codec_chunk_shape(chunk_shape: Any, expected: tuple[int, ...]) -> None:
+    """The inner chunk shape of a shard is parsed by the chunk normalizer's integer test as
+    a regular chunk shape: one integer of at least 1 per dimension, written back as
+    given."""
+    codec = ShardingCodec(chunk_shape=chunk_shape)
+    assert codec.chunk_shape == expected
+    assert all(type(size) is int for size in codec.chunk_shape)
+    configuration = cast("dict[str, JSON]", codec.to_dict()["configuration"])
+    assert configuration["chunk_shape"] == expected
+    assert ShardingCodec.from_dict(codec.to_dict()).chunk_shape == expected
+
+
+@pytest.mark.parametrize("chunk_shape", [(0,), (False,), (-1,), 0, [8, 0]], ids=repr)
+def test_sharding_codec_chunk_shape_rejects_non_positive(chunk_shape: Any) -> None:
+    """An inner chunk size below 1 is rejected, including `-1` and `False`, which have no
+    axis length to be resolved against."""
+    with pytest.raises(ValueError, match="All chunk sizes must be positive"):
+        ShardingCodec(chunk_shape=chunk_shape)
+
+
+@pytest.mark.parametrize("chunk_shape", [[[4, 4]], [8, [4, 4]], (4.0,), "4"], ids=repr)
+def test_sharding_codec_chunk_shape_rejects_non_integer(chunk_shape: Any) -> None:
+    """An inner chunk shape is regular: an explicit list of chunk edges, which declares a
+    rectilinear dimension, is rejected like any other non-integer chunk size."""
+    with pytest.raises(TypeError, match="Each chunk size of a regular chunk shape must be"):
+        ShardingCodec(chunk_shape=chunk_shape)
+
+
+def test_sharding_codec_chunk_shape_rejects_non_iterable() -> None:
+    with pytest.raises(TypeError, match="must be an integer or an iterable of integers"):
+        ShardingCodec(chunk_shape=None)  # type: ignore[arg-type]
@@ -331,7 +331,7 @@ def test_read_invalid_edges_in_rectilinear_grid(
         (_v3_doc([4], [4.5]), "Dimension 0: chunk edge length must be an int, got 4.5"),
         (
             _v3_doc([8], [4], inner=[2.0]),
-            "Expected an iterable of integers. Got [2.0] instead.",
+            "got non-integer element(s) (2.0,) at indices (0,)",
         ),
         (_v2_doc([20], [10.0]), "Expected an iterable of integers. Got [10.0] instead."),
         (
@@ -494,18 +494,12 @@ def test_regular_chunk_grid_rejects_chunk_shape_not_a_sequence(chunk_shape: Any)
         RegularChunkGridMetadata(chunk_shape=chunk_shape)
 
 
-def _sharding_chunk_shape(chunks: Any) -> tuple[tuple[int, ...], object]:
-    codec = ShardingCodec(chunk_shape=chunks)
-    configuration = cast("dict[str, JSON]", codec.to_dict()["configuration"])
-    return codec.chunk_shape, configuration["chunk_shape"]
-
-
 CHUNK_SHAPE_SITES: dict[str, Callable[[Any], tuple[tuple[int, ...], object]]] = {
     "v2": lambda chunks: ((md := _v2_metadata(chunks)).chunks, md.to_dict()["chunks"]),
-    "sharding-inner": _sharding_chunk_shape,
 }
-"""`ArrayV2Metadata` and `ShardingCodec` read a chunk shape as an array shape, returning
-the chunk shape and the value `to_dict` writes for it."""
+"""`ArrayV2Metadata` reads a chunk shape as an array shape, returning the chunk shape
+and the value `to_dict` writes for it. The inner chunk shape of `ShardingCodec` is a
+regular chunk shape instead (see `test_sharding_codec_chunk_shape`)."""
 
 
 @pytest.mark.parametrize("site", CHUNK_SHAPE_SITES)
@@ -527,7 +521,7 @@ def _sharding_chunk_shape(chunks: Any) -> tuple[tuple[int, ...], object]:
 def test_chunk_shape_read_as_array_shape(
     site: str, chunks: object, expected: tuple[int, ...]
 ) -> None:
-    """`ArrayV2Metadata` and `ShardingCodec` read their chunk shape as `parse_shapelike`
+    """`ArrayV2Metadata` reads its chunk shape as `parse_shapelike`
     reads an array shape: an integer or an iterable of non-negative integers, including
     NumPy integers and bools. A chunk size of 0 is written back as given; reading a
     stored 0 is `zarr.core.metadata.repair`' business."""
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-Chunk specifications are judged only by the chunk normalizer: the separate duck-typed check for rectilinear input is gone, so the Zarr format 2 and sharding restrictions apply to what the normalized grid says was declared. A chunk size is an integer by Python's integer protocol: numpy integer scalars and 0-d integer arrays are accepted wherever a chunk or shard shape is. The legacy `zarr.create(..., zarr_format=2)` no longer tests the truth value of `chunks`: only `None` means not given, as for Zarr format 3. `chunks=False` is now one chunk instead of an automatic chunk shape, numpy arrays work, and `0`, `[]` and `np.array([0])` raise instead of chunking automatically. A non-integer scalar chunk specification raises a `TypeError` naming the problem. An explicit list of chunk edges declares a rectilinear dimension everywhere, including a stored rectilinear chunk grid passed as `chunks=` whose edges happen to be uniform, so the Zarr format 2 and sharding restrictions treat it the same whether it is given as lists or as metadata, and `zarr.create` stores it as a rectilinear chunk grid, as `create_array` does. A `RectilinearChunkGridMetadata` made only of bare integers declares no explicit edge list, so it is read as the regular grid it describes: it is accepted for Zarr format 2 and as the chunk shape of a sharded array. The `chunks` and `chunk_shape` parameters of `zarr.create` and the `ShardsLike` type now declare every chunk specification the normalizer accepts, including numpy integers and arrays, explicit edge lists and stored chunk grid metadata.
	`1`	+Chunk specifications are judged only by the chunk normalizer: the separate duck-typed check for rectilinear input is gone, so the Zarr format 2 and sharding restrictions apply to what the normalized grid says was declared. A chunk size is an integer by Python's integer protocol: numpy integer scalars and 0-d integer arrays are accepted wherever a chunk or shard shape is. The legacy `zarr.create(..., zarr_format=2)` no longer tests the truth value of `chunks`: only `None` means not given, as for Zarr format 3. `chunks=False` is now one chunk instead of an automatic chunk shape, numpy arrays work, and `0`, `[]` and `np.array([0])` raise instead of chunking automatically. A non-integer scalar chunk specification raises a `TypeError` naming the problem. An explicit list of chunk edges declares a rectilinear dimension everywhere, including a stored rectilinear chunk grid passed as `chunks=` whose edges happen to be uniform, so the Zarr format 2 and sharding restrictions treat it the same whether it is given as lists or as metadata, and `zarr.create` stores it as a rectilinear chunk grid, as `create_array` does. A `RectilinearChunkGridMetadata` made only of bare integers declares no explicit edge list, so it is read as the regular grid it describes: it is accepted for Zarr format 2 and as the chunk shape of a sharded array. The `chunks` and `chunk_shape` parameters of `zarr.create` and the `ShardsLike` type now declare every chunk specification the normalizer accepts, including numpy integers and arrays, explicit edge lists and stored chunk grid metadata. The inner chunk shape of `ShardingCodec` is parsed with the chunk normalizer's integer test as a regular chunk shape: every size must be at least 1, so a stored or given inner chunk size of 0 raises a `ValueError` instead of a `ZeroDivisionError` on read, and an explicit list of chunk edges is rejected with a `TypeError`.