@@ -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. 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`.
+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 chunk shape of `ArrayV2Metadata` and the inner chunk shape of `ShardingCodec` are parsed with the chunk normalizer's integer test as a regular chunk shape: every size must be at least 1, so `ArrayV2Metadata(chunks=(0,))` raises a `ValueError` as the Zarr format 3 regular chunk grid does (a stored Zarr format 2 chunk size of 0 is still repaired on read), a stored 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`.
@@ -33,6 +33,7 @@
 
 from zarr.core._json import json_to_buffer
 from zarr.core.array_spec import ArrayConfig, ArraySpec
+from zarr.core.chunk_grids import parse_regular_chunk_shape
 from zarr.core.chunk_key_encodings import parse_separator
 from zarr.core.common import (
     JSON,
@@ -331,9 +332,10 @@ def parse_compressor(data: object) -> Numcodec | None:
 
 
 def parse_chunks(chunks: ShapeLike, shape: tuple[int, ...]) -> tuple[int, ...]:
-    """Check a chunk shape: one non-negative integer per array axis (see
-    `parse_shapelike`). Stored chunk sizes of 0 are read by `zarr.core.metadata.repair`."""
-    chunks_parsed = parse_shapelike(chunks)
+    """Check a chunk shape: one integer of at least 1 per array axis, as a regular chunk
+    shape (see `parse_regular_chunk_shape`). Stored chunk sizes of 0 are read by
+    `zarr.core.metadata.repair` before they get here."""
+    chunks_parsed = parse_regular_chunk_shape(chunks)
     if len(chunks_parsed) != len(shape):
         raise ValueError(
             f"The `shape` and `chunks` attributes must have the same length. "
 
@@ -2,7 +2,7 @@
 import math
 import pickle
 import warnings
-from typing import TYPE_CHECKING, Any, cast, get_args
+from typing import Any, cast, get_args
 from unittest.mock import AsyncMock
 
 import numpy as np
@@ -40,9 +40,6 @@
 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
@@ -1396,51 +1393,3 @@ 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]
@@ -254,7 +254,7 @@ def _open_strictly(path: Path, mode: Literal["r", "a", "r+"] = "r") -> AnyArray:
 
 def test_stored_negative_chunk_size_rejected() -> None:
     """No known writer stored a negative chunk size: it is rejected, not repaired."""
-    with pytest.raises(ValueError, match="^Expected all values to be non-negative"):
+    with pytest.raises(ValueError, match=r"^All chunk sizes must be positive, got \[-1\]$"):
         _read_strictly(_v2_doc([4], [-1]))
 
 
@@ -333,7 +333,7 @@ def test_read_invalid_edges_in_rectilinear_grid(
             _v3_doc([8], [4], inner=[2.0]),
             "got non-integer element(s) (2.0,) at indices (0,)",
         ),
-        (_v2_doc([20], [10.0]), "Expected an iterable of integers. Got [10.0] instead."),
+        (_v2_doc([20], [10.0]), "got non-integer element(s) (10.0,) at indices (0,)"),
         (
             _rectilinear_doc([8], [[[4, 2.0]]]),
             "Dimension 0: RLE repeat count must be an int, got 2.0",
@@ -494,12 +494,19 @@ 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` 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`)."""
+"""`ArrayV2Metadata` and `ShardingCodec` read a regular chunk shape (see
+`parse_regular_chunk_shape`), returning the chunk shape and the value `to_dict` writes
+for it."""
 
 
 @pytest.mark.parametrize("site", CHUNK_SHAPE_SITES)
@@ -513,37 +520,44 @@ def test_regular_chunk_grid_rejects_chunk_shape_not_a_sequence(chunk_shape: Any)
         ((np.int64(4),), (4,)),
         (np.array([4]), (4,)),
         ((True,), (1,)),
-        ((0,), (0,)),
-        ((False,), (0,)),
         (range(4, 5), (4,)),
     ],
 )
-def test_chunk_shape_read_as_array_shape(
-    site: str, chunks: object, expected: tuple[int, ...]
-) -> None:
-    """`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."""
+def test_regular_chunk_shape(site: str, chunks: object, expected: tuple[int, ...]) -> None:
+    """`ArrayV2Metadata` and `ShardingCodec` read their chunk shape with the chunk
+    normalizer's integer test: an integer or an iterable of integers of at least 1,
+    including NumPy integers and bools, written back as given. Reading a stored 0 is
+    `zarr.core.metadata.repair`' business, before the constructors see it."""
     parsed, written = CHUNK_SHAPE_SITES[site](chunks)
     assert parsed == expected
     assert all(type(size) is int for size in parsed)
     assert written == expected
 
 
 @pytest.mark.parametrize("site", CHUNK_SHAPE_SITES)
-def test_chunk_shape_read_as_array_shape_rejects_negative(site: str) -> None:
-    with pytest.raises(ValueError, match="Expected all values to be non-negative"):
-        CHUNK_SHAPE_SITES[site]((-1,))
+@pytest.mark.parametrize("chunks", [(0,), (False,), (-1,), 0])
+def test_regular_chunk_shape_rejects_non_positive(site: str, chunks: object) -> None:
+    """A chunk size below 1 is rejected, including `-1` and `False`, which have no axis
+    length to be resolved against here."""
+    with pytest.raises(ValueError, match="All chunk sizes must be positive"):
+        CHUNK_SHAPE_SITES[site](chunks)
 
 
 @pytest.mark.parametrize("site", CHUNK_SHAPE_SITES)
-@pytest.mark.parametrize("chunks", [(4.0,), "4", None])
-def test_chunk_shape_read_as_array_shape_rejects_non_integer(site: str, chunks: object) -> None:
-    with pytest.raises(TypeError, match="Expected an"):
+@pytest.mark.parametrize("chunks", [(4.0,), "4", [[2, 2]]])
+def test_regular_chunk_shape_rejects_non_integer(site: str, chunks: object) -> None:
+    """A non-integer chunk size is rejected, and so is an explicit list of chunk edges,
+    which declares a rectilinear dimension that a regular chunk shape cannot have."""
+    with pytest.raises(TypeError, match="Each chunk size of a regular chunk shape must be"):
         CHUNK_SHAPE_SITES[site](chunks)
 
 
+@pytest.mark.parametrize("site", CHUNK_SHAPE_SITES)
+def test_regular_chunk_shape_rejects_non_iterable(site: str) -> None:
+    with pytest.raises(TypeError, match="must be an integer or an iterable of integers"):
+        CHUNK_SHAPE_SITES[site](None)
+
+
 def _rewrite_doc(path: Path, zarr_format: Literal[2, 3], edit: Any) -> None:
     doc_path = path / (".zarray" if zarr_format == 2 else "zarr.json")
     doc = json.loads(doc_path.read_text())
@@ -971,30 +985,6 @@ def test_from_dict_keeps_values_that_are_not_json(codec: Any) -> None:
     assert isinstance(metadata.codecs[0], ShardingCodec)
 
 
-@pytest.mark.parametrize(("shape", "expected"), [((0,), (1,)), ((3,), (1,))])
-def test_array_from_metadata_with_chunk_size_zero(shape: tuple[int], expected: tuple[int]) -> None:
-    """`ArrayV2Metadata` accepts a chunk size of 0, as a stored document may hold it. An
-    array built from such metadata reads it as the repairs read that document, silently
-    (no data was read or written under it): `create_hierarchy` stores the metadata as
-    given and yields such an array, which stores the repair before its first write."""
-    metadata = ArrayV2Metadata(shape=shape, chunks=(0,), dtype=Int16(), fill_value=0, order="C")
-    store = MemoryStore()
-    with warnings.catch_warnings():
-        warnings.simplefilter("error", ZarrUserWarning)
-        nodes = dict(zarr.create_hierarchy(store=store, nodes={"a": metadata}))
-    array = nodes["a"]
-    assert isinstance(array, zarr.Array)
-    assert array.chunks == expected
-    assert json.loads(store._store_dict["a/.zarray"].to_bytes())["chunks"] == [0]
-
-    array[...] = 1
-
-    # Writing an empty selection stores no chunks, so it stores no metadata either.
-    resaved = list(expected) if array.size else [0]
-    assert json.loads(store._store_dict["a/.zarray"].to_bytes())["chunks"] == resaved
-    np.testing.assert_array_equal(zarr.open_array(store, path="a")[...], np.ones(shape))
-
-
 def test_array_from_metadata_with_numpy_scalar_codec_configuration() -> None:
     """An array is built from metadata whose codec configuration holds NumPy scalars
     (which are not JSON values), as zarr always built one."""
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. 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`.
	`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 chunk shape of `ArrayV2Metadata` and the inner chunk shape of `ShardingCodec` are parsed with the chunk normalizer's integer test as a regular chunk shape: every size must be at least 1, so `ArrayV2Metadata(chunks=(0,))` raises a `ValueError` as the Zarr format 3 regular chunk grid does (a stored Zarr format 2 chunk size of 0 is still repaired on read), a stored 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`.